@trapi/metadata 0.2.0 → 0.2.1

package/dist/resolver/type-node.js

@@ -1,1045 +0,0 @@
-"use strict";
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeNodeResolver = void 0;
-const ts = __importStar(require("typescript"));
-const metadata_utils_1 = require("@trapi/metadata-utils");
-const decorator_1 = require("../decorator");
-const utils_1 = require("../utils");
-const error_1 = require("./error");
-const utils_2 = require("./utils");
-const localReferenceTypeCache = {};
-const inProgressTypes = {};
-function getPropertyValidators(property) {
-    return {};
-}
-class TypeNodeResolver {
-    constructor(typeNode, current, parentNode, context = {}, referencer) {
-        this.typeNode = typeNode;
-        this.current = current;
-        this.parentNode = parentNode;
-        this.context = context;
-        this.referencer = referencer;
-        this.attemptToResolveKindToPrimitive = (syntaxKind) => {
-            if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
-                return 'number';
-            }
-            if (syntaxKind === ts.SyntaxKind.StringKeyword) {
-                return 'string';
-            }
-            if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
-                return 'boolean';
-            }
-            if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
-                return 'void';
-            }
-            return undefined;
-        };
-    }
-    static clearCache() {
-        Object.keys(localReferenceTypeCache).forEach((key) => {
-            delete localReferenceTypeCache[key];
-        });
-        Object.keys(inProgressTypes).forEach((key) => {
-            delete inProgressTypes[key];
-        });
-    }
-    resolve() {
-        const primitiveType = this.getPrimitiveType(this.typeNode, this.parentNode);
-        if (primitiveType) {
-            return primitiveType;
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.NullKeyword) {
-            return {
-                typeName: 'enum',
-                members: [null],
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return {
-                typeName: 'array',
-                elementType: new TypeNodeResolver(this.typeNode.elementType, this.current, this.parentNode, this.context).resolve(),
-            };
-        }
-        if (ts.isUnionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
-            return {
-                typeName: 'union',
-                members: types,
-            };
-        }
-        if (ts.isIntersectionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
-            return {
-                typeName: 'intersection',
-                members: types,
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.AnyKeyword || this.typeNode.kind === ts.SyntaxKind.UnknownKeyword || this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
-            return {
-                typeName: 'any',
-            };
-        }
-        if (ts.isLiteralTypeNode(this.typeNode)) {
-            return {
-                typeName: 'enum',
-                members: [TypeNodeResolver.getLiteralValue(this.typeNode)],
-            };
-        }
-        if (ts.isTypeLiteralNode(this.typeNode)) {
-            const properties = this.typeNode.members
-                .filter((member) => ts.isPropertySignature(member))
-                .reduce((res, propertySignature) => {
-                const type = new TypeNodeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve();
-                const property = {
-                    deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, (tag) => tag.tagName.text === 'deprecated'),
-                    example: TypeNodeResolver.getNodeExample(propertySignature),
-                    default: (0, utils_1.getJSDocTagComment)(propertySignature, 'default'),
-                    description: this.getNodeDescription(propertySignature),
-                    format: TypeNodeResolver.getNodeFormat(propertySignature),
-                    name: propertySignature.name.text,
-                    required: !propertySignature.questionToken,
-                    type,
-                    validators: getPropertyValidators(propertySignature) || {},
-                };
-                return [property, ...res];
-            }, []);
-            const indexMember = this.typeNode.members.find((member) => ts.isIndexSignatureDeclaration(member));
-            let additionalType;
-            if (indexMember) {
-                const indexSignatureDeclaration = indexMember;
-                const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-                if (indexType.typeName !== 'string') {
-                    throw new error_1.ResolverError('Only string indexes are supported.', this.typeNode);
-                }
-                additionalType = new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
-            }
-            return {
-                additionalProperties: indexMember && additionalType,
-                typeName: 'nestedObjectLiteral',
-                properties,
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword || ts.isFunctionTypeNode(this.typeNode)) {
-            return { typeName: 'object' };
-        }
-        if (ts.isMappedTypeNode(this.typeNode) && this.referencer) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
-            const mappedTypeNode = this.typeNode;
-            const { typeChecker } = this.current;
-            const getDeclaration = (prop) => prop.declarations && prop.declarations[0];
-            const isIgnored = (prop) => {
-                const declaration = getDeclaration(prop);
-                return (prop.getJsDocTags().find((tag) => tag.name === 'ignore') !== undefined ||
-                    (declaration !== undefined && !ts.isPropertyDeclaration(declaration) && !ts.isPropertySignature(declaration) && !ts.isParameter(declaration)));
-            };
-            const properties = type
-                .getProperties()
-                // Ignore methods, getter, setter and @ignored props
-                .filter((property) => isIgnored(property) === false)
-                // Transform to property
-                .map((property) => {
-                const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
-                const declaration = getDeclaration(property);
-                if (declaration && ts.isPropertySignature(declaration)) {
-                    return Object.assign(Object.assign({}, this.propertyFromSignature(declaration, mappedTypeNode.questionToken)), { name: property.getName() });
-                }
-                if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) {
-                    return Object.assign(Object.assign({}, this.propertyFromDeclaration(declaration, mappedTypeNode.questionToken)), { name: property.getName() });
-                }
-                // Resolve default value, required and typeNode
-                let required = false;
-                const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
-                if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.MinusToken) {
-                    required = true;
-                }
-                else if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.QuestionToken) {
-                    required = false;
-                }
-                // Push property
-                return {
-                    name: property.getName(),
-                    required,
-                    deprecated: false,
-                    type: new TypeNodeResolver(typeNode, this.current, this.typeNode, this.context, this.referencer).resolve(),
-                    validators: {},
-                };
-            });
-            return {
-                typeName: 'nestedObjectLiteral',
-                properties,
-            };
-        }
-        if (ts.isConditionalTypeNode(this.typeNode) && this.referencer && ts.isTypeReferenceNode(this.referencer)) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
-            if (type.aliasSymbol) {
-                let declaration = type.aliasSymbol.declarations[0];
-                if (declaration.name) {
-                    declaration = this.getModelTypeDeclaration(declaration.name);
-                }
-                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
-                return this.handleCachingAndCircularReferences(name, () => {
-                    if (ts.isTypeAliasDeclaration(declaration)) {
-                        // Note: I don't understand why typescript lose type for `this.referencer` (from above with isTypeReferenceNode())
-                        return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
-                    }
-                    if (ts.isEnumDeclaration(declaration)) {
-                        return this.getEnumerateType(declaration.name);
-                    }
-                    throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
-                });
-            }
-            if (type.isClassOrInterface()) {
-                let declaration = type.symbol.declarations[0];
-                if (declaration.name) {
-                    declaration = this.getModelTypeDeclaration(declaration.name);
-                }
-                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
-                return this.handleCachingAndCircularReferences(name, () => this.getModelReference(declaration, this.current.typeChecker.typeToString(type)));
-            }
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch (_a) {
-                throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
-            }
-        }
-        if (ts.isTypeOperatorNode(this.typeNode) && this.typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch (err) {
-                const indexedTypeName = this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.type));
-                throw new error_1.ResolverError(`Could not determine the keys on ${indexedTypeName}`, this.typeNode);
-            }
-        }
-        if (ts.isIndexedAccessTypeNode(this.typeNode) && (this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword || this.typeNode.indexType.kind === ts.SyntaxKind.StringKeyword)) {
-            const numberIndexType = this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword;
-            const objectType = this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType);
-            const type = numberIndexType ? objectType.getNumberIndexType() : objectType.getStringIndexType();
-            if (type === undefined) {
-                throw new error_1.ResolverError(`Could not determine ${numberIndexType ? 'number' : 'string'} index on ${this.current.typeChecker.typeToString(objectType)}`, this.typeNode);
-            }
-            return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
-        }
-        if (ts.isIndexedAccessTypeNode(this.typeNode) &&
-            ts.isLiteralTypeNode(this.typeNode.indexType) &&
-            (ts.isStringLiteral(this.typeNode.indexType.literal) || ts.isNumericLiteral(this.typeNode.indexType.literal))) {
-            const hasType = (node) => node !== undefined && node.hasOwnProperty('type');
-            const symbol = this.current.typeChecker.getPropertyOfType(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType), this.typeNode.indexType.literal.text);
-            if (symbol === undefined) {
-                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType))}`, this.typeNode);
-            }
-            if (hasType(symbol.valueDeclaration) && symbol.valueDeclaration.type) {
-                return new TypeNodeResolver(symbol.valueDeclaration.type, this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            const declaration = this.current.typeChecker.getTypeOfSymbolAtLocation(symbol, this.typeNode.objectType);
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch (_b) {
-                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined)))}`, this.typeNode);
-            }
-        }
-        // @ts-ignore
-        if (this.typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
-            if (type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral())) {
-                return {
-                    typeName: 'enum',
-                    members: type.types.map((stringLiteralType) => stringLiteralType.value),
-                };
-            }
-            throw new error_1.ResolverError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode);
-        }
-        if (ts.isParenthesizedTypeNode(this.typeNode)) {
-            return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
-        }
-        if (this.typeNode.kind !== ts.SyntaxKind.TypeReference) {
-            throw new error_1.ResolverError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode);
-        }
-        const typeReference = this.typeNode;
-        if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
-            // Special Utility Type
-            if (typeReference.typeName.text === 'Record') {
-                return {
-                    additionalProperties: new TypeNodeResolver(typeReference.typeArguments[1], this.current, this.parentNode, this.context).resolve(),
-                    typeName: 'nestedObjectLiteral',
-                    properties: [],
-                };
-            }
-            const specialReference = TypeNodeResolver.resolveSpecialReference(typeReference.typeName);
-            if (typeof specialReference !== 'undefined') {
-                return specialReference;
-            }
-            if (typeReference.typeName.text === 'Date') {
-                return this.getDateType(this.parentNode);
-            }
-            if (typeReference.typeName.text === 'Buffer' || typeReference.typeName.text === 'Readable') {
-                return { typeName: 'buffer' };
-            }
-            if (typeReference.typeName.text === 'Array' && typeReference.typeArguments && typeReference.typeArguments.length >= 1) {
-                return {
-                    typeName: 'array',
-                    elementType: new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve(),
-                };
-            }
-            if (typeReference.typeName.text === 'Promise' && typeReference.typeArguments && typeReference.typeArguments.length === 1) {
-                return new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve();
-            }
-            if (typeReference.typeName.text === 'String') {
-                return { typeName: 'string' };
-            }
-            if (this.context[typeReference.typeName.text]) {
-                return new TypeNodeResolver(this.context[typeReference.typeName.text], this.current, this.parentNode, this.context).resolve();
-            }
-        }
-        const referenceType = this.getReferenceType(typeReference);
-        this.current.addReferenceType(referenceType);
-        return referenceType;
-    }
-    // ------------------------------------------------------------------------
-    // Utility Type(s)
-    // ------------------------------------------------------------------------
-    static isSupportedUtilityType(typeName) {
-        if (typeof typeName === 'undefined') {
-            return false;
-        }
-        return ['NonNullable', 'Pick', 'Omit', 'Partial', 'Readonly', 'Record', 'Required'].indexOf(typeof typeName !== 'string' ? typeName.text : typeName) !== -1;
-    }
-    static getUtilityTypeOptions(typeArguments) {
-        const utilityOptions = {
-            keys: [],
-        };
-        if (typeArguments.length >= 2) {
-            if (ts.isUnionTypeNode(typeArguments[1])) {
-                const args = typeArguments[1].types;
-                for (let i = 0; i < args.length; i++) {
-                    if (ts.isLiteralTypeNode(args[i])) {
-                        utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(args[i]));
-                    }
-                }
-            }
-            if (ts.isLiteralTypeNode(typeArguments[1])) {
-                utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(typeArguments[1]));
-            }
-        }
-        return utilityOptions;
-    }
-    filterUtilityProperties(properties, utilityType, utilityOptions) {
-        if (typeof utilityType === 'undefined' || typeof utilityOptions === 'undefined') {
-            return properties;
-        }
-        return properties
-            .filter((property) => {
-            const name = typeof property.name !== 'string' ? property.name.text : property.name;
-            switch (utilityType) {
-                case 'Pick':
-                    return utilityOptions.keys.indexOf(name) !== -1;
-                case 'Omit':
-                    return utilityOptions.keys.indexOf(name) === -1;
-            }
-            return true;
-        })
-            .map((property) => {
-            if ((0, metadata_utils_1.hasOwnProperty)(property, 'required')) {
-                switch (utilityType) {
-                    case 'Partial':
-                        property.required = false;
-                        break;
-                    case 'Required':
-                    case 'NonNullable':
-                        property.required = true;
-                        break;
-                }
-            }
-            return property;
-        });
-    }
-    static resolveSpecialReference(node) {
-        switch (node.text) {
-            case 'Buffer':
-            case 'DownloadBinaryData':
-            case 'DownloadResource':
-                return { typeName: 'buffer' };
-            default:
-                return undefined;
-        }
-    }
-    static getLiteralValue(typeNode) {
-        let value;
-        switch (typeNode.literal.kind) {
-            case ts.SyntaxKind.TrueKeyword:
-                value = true;
-                break;
-            case ts.SyntaxKind.FalseKeyword:
-                value = false;
-                break;
-            case ts.SyntaxKind.StringLiteral:
-                value = typeNode.literal.text;
-                break;
-            case ts.SyntaxKind.NumericLiteral:
-                value = parseFloat(typeNode.literal.text);
-                break;
-            case ts.SyntaxKind.NullKeyword:
-                value = null;
-                break;
-            default:
-                if (typeNode.literal.hasOwnProperty('text')) {
-                    value = typeNode.literal.text;
-                }
-                else {
-                    throw new error_1.ResolverError(`Couldn't resolve literal node: ${typeNode.literal.getText()}`);
-                }
-        }
-        return value;
-    }
-    getPrimitiveType(typeNode, parentNode) {
-        if (!typeNode) {
-            return {
-                typeName: 'void',
-            };
-        }
-        const resolvedType = this.attemptToResolveKindToPrimitive(typeNode.kind);
-        if (typeof resolvedType === 'undefined') {
-            return undefined;
-        }
-        if (resolvedType === 'number') {
-            if (!parentNode) {
-                return { typeName: 'double' };
-            }
-            const tags = (0, utils_1.getJSDocTagNames)(parentNode)
-                .filter((name) => [
-                'isInt',
-                'isLong',
-                'isFloat',
-                'isDouble',
-            ].some((m) => m.toLowerCase() === name.toLowerCase()))
-                .map((name) => name.toLowerCase());
-            const data = (0, decorator_1.getNodeDecorators)(parentNode, (identifier) => [
-                'isInt',
-                'isLong',
-                'isFloat',
-                'isDouble',
-            ].some((m) => m.toLowerCase() === identifier.text.toLowerCase()));
-            let decorator = data.length > 0 ? data[0].text : undefined;
-            if (typeof decorator !== 'undefined') {
-                decorator = decorator.toLowerCase();
-            }
-            if (!decorator && tags.length === 0) {
-                return { typeName: 'double' };
-            }
-            switch (decorator || tags[0]) {
-                case 'isint':
-                    return { typeName: 'integer' };
-                case 'islong':
-                    return { typeName: 'long' };
-                case 'isfloat':
-                    return { typeName: 'float' };
-                case 'isdouble':
-                    return { typeName: 'double' };
-                default:
-                    return { typeName: 'double' };
-            }
-        }
-        else if (resolvedType === 'string') {
-            return {
-                typeName: 'string',
-            };
-        }
-        else if (resolvedType === 'boolean') {
-            return {
-                typeName: 'boolean',
-            };
-        }
-        else if (resolvedType === 'void') {
-            return {
-                typeName: 'void',
-            };
-        }
-        else {
-            // todo: should not occur
-            return resolvedType;
-        }
-    }
-    getDateType(parentNode) {
-        if (!parentNode) {
-            return { typeName: 'datetime' };
-        }
-        const tags = (0, utils_1.getJSDocTagNames)(parentNode).filter((name) => ['isDate', 'isDateTime'].some((m) => m === name));
-        if (tags.length === 0) {
-            return { typeName: 'datetime' };
-        }
-        switch (tags[0]) {
-            case 'isDate':
-                return { typeName: 'date' };
-            case 'isDateTime':
-                return { typeName: 'datetime' };
-            default:
-                return { typeName: 'datetime' };
-        }
-    }
-    static getDesignatedModels(nodes, typeName) {
-        return nodes;
-    }
-    getEnumerateType(typeName) {
-        const enumName = typeName.text;
-        let enumNodes = this.current.nodes.filter((node) => node.kind === ts.SyntaxKind.EnumDeclaration).filter((node) => node.name.text === enumName);
-        if (!enumNodes.length) {
-            return undefined;
-        }
-        enumNodes = TypeNodeResolver.getDesignatedModels(enumNodes, enumName);
-        if (enumNodes.length > 1) {
-            throw new error_1.ResolverError(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
-        }
-        const enumDeclaration = enumNodes[0];
-        const isNotUndefined = (item) => item !== undefined;
-        const enums = enumDeclaration.members.map(this.current.typeChecker.getConstantValue.bind(this.current.typeChecker)).filter(isNotUndefined);
-        const enumNames = enumDeclaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
-        return {
-            typeName: 'refEnum',
-            description: this.getNodeDescription(enumDeclaration),
-            members: enums,
-            memberNames: enumNames,
-            refName: enumName,
-            deprecated: (0, utils_1.isExistJSDocTag)(enumDeclaration, (tag) => tag.tagName.text === 'deprecated'),
-        };
-    }
-    getReferenceType(node) {
-        let type;
-        if (ts.isTypeReferenceNode(node)) {
-            type = node.typeName;
-        }
-        else if (ts.isExpressionWithTypeArguments(node)) {
-            type = node.expression;
-        }
-        else {
-            throw new error_1.ResolverError('Can\'t resolve Reference type.');
-        }
-        // Can't invoke getText on Synthetic Nodes
-        let resolvableName = node.pos !== -1 ? node.getText() : type.text;
-        if (node.pos === -1 && 'typeArguments' in node && Array.isArray(node.typeArguments)) {
-            // Add typeArguments for Synthetic nodes (e.g. Record<> in TestClassModel.indexedResponse)
-            const argumentsString = node.typeArguments
-                .map((arg) => {
-                if (ts.isLiteralTypeNode(arg)) {
-                    return `'${String(TypeNodeResolver.getLiteralValue(arg))}'`;
-                }
-                const resolvedType = this.attemptToResolveKindToPrimitive(arg.kind);
-                if (typeof resolvedType === 'undefined') {
-                    return 'any';
-                }
-                return resolvedType;
-            });
-            resolvableName += `<${argumentsString.join(', ')}>`;
-        }
-        const name = this.contextualizedName(resolvableName);
-        // Handle Utility Types
-        const identifierName = type.text;
-        const utilityTypeSupported = TypeNodeResolver.isSupportedUtilityType(identifierName);
-        const utilityType = utilityTypeSupported ? identifierName : undefined;
-        let utilityOptions = {
-            keys: [],
-        };
-        if (utilityTypeSupported) {
-            const { typeArguments } = type.parent;
-            if (ts.isTypeReferenceNode(typeArguments[0])) {
-                type = typeArguments[0].typeName;
-            }
-            else if (ts.isExpressionWithTypeArguments(typeArguments[0])) {
-                type = typeArguments[0].expression;
-            }
-            else {
-                throw new error_1.ResolverError('Can\'t resolve Reference type.');
-            }
-            utilityOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
-        }
-        else {
-            this.typeArgumentsToContext(node, type, this.context);
-        }
-        try {
-            const existingType = localReferenceTypeCache[name];
-            if (existingType) {
-                return existingType;
-            }
-            const refEnumType = this.getEnumerateType(type);
-            if (refEnumType) {
-                localReferenceTypeCache[name] = refEnumType;
-                return refEnumType;
-            }
-            if (inProgressTypes[name]) {
-                return this.createCircularDependencyResolver(name);
-            }
-            inProgressTypes[name] = true;
-            const declaration = this.getModelTypeDeclaration(type);
-            let referenceType;
-            if (ts.isTypeAliasDeclaration(declaration)) {
-                referenceType = this.getTypeAliasReference(declaration, name, node);
-            }
-            else if (ts.isEnumMember(declaration)) {
-                referenceType = {
-                    typeName: 'refEnum',
-                    refName: TypeNodeResolver.getRefTypeName(name, utilityType),
-                    members: [this.current.typeChecker.getConstantValue(declaration)],
-                    // @ts-ignore
-                    memberNames: [declaration.name.getText()],
-                    deprecated: (0, utils_1.isExistJSDocTag)(declaration, (tag) => tag.tagName.text === 'deprecated'),
-                };
-            }
-            else {
-                referenceType = this.getModelReference(declaration, name, utilityType, utilityOptions);
-            }
-            localReferenceTypeCache[name] = referenceType;
-            return referenceType;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(`There was a problem resolving type of '${name}'.`);
-            throw err;
-        }
-    }
-    getTypeAliasReference(declaration, name, referencer) {
-        const refName = TypeNodeResolver.getRefTypeName(name);
-        let type;
-        if (declaration.type.kind === ts.SyntaxKind.TypeReference) {
-            const referenceType = this.getReferenceType(declaration.type);
-            if (referenceType.refName === refName) {
-                return referenceType;
-            }
-        }
-        if (typeof type === 'undefined') {
-            type = new TypeNodeResolver(declaration.type, this.current, declaration, this.context, this.referencer || referencer).resolve();
-        }
-        const example = TypeNodeResolver.getNodeExample(declaration);
-        return Object.assign({ typeName: 'refAlias', default: (0, utils_1.getJSDocTagComment)(declaration, 'default'), description: this.getNodeDescription(declaration), refName, format: TypeNodeResolver.getNodeFormat(declaration), type, validators: getPropertyValidators(declaration) || {}, deprecated: (0, utils_1.isExistJSDocTag)(declaration, (tag) => tag.tagName.text === 'deprecated') }, (example && { example }));
-    }
-    getModelReference(modelType, name, utilityType, utilityOptions) {
-        const example = TypeNodeResolver.getNodeExample(modelType);
-        const description = this.getNodeDescription(modelType);
-        const deprecated = (0, utils_1.isExistJSDocTag)(modelType, (tag) => tag.tagName.text === 'deprecated') || typeof this.current.decoratorMapper.match('DEPRECATED', modelType) !== 'undefined';
-        // Handle toJSON methods
-        if (!modelType.name) {
-            throw new error_1.ResolverError('Can\'t get Symbol from anonymous class', modelType);
-        }
-        const type = this.current.typeChecker.getTypeAtLocation(modelType.name);
-        const toJSON = this.current.typeChecker.getPropertyOfType(type, 'toJSON');
-        if (toJSON && toJSON.valueDeclaration && (ts.isMethodDeclaration(toJSON.valueDeclaration) || ts.isMethodSignature(toJSON.valueDeclaration))) {
-            let nodeType = toJSON.valueDeclaration.type;
-            if (!nodeType) {
-                const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
-                const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
-                nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
-            }
-            return Object.assign({ refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`, typeName: 'refAlias', description, type: new TypeNodeResolver(nodeType, this.current).resolve(), deprecated, validators: {} }, (example && { example }));
-        }
-        const properties = this.getModelProperties(modelType, undefined, utilityType, utilityOptions);
-        const additionalProperties = this.getModelAdditionalProperties(modelType);
-        const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
-        const referenceType = Object.assign({ additionalProperties, typeName: 'refObject', description, properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions), refName: TypeNodeResolver.getRefTypeName(name, utilityType), deprecated }, (example && { example }));
-        referenceType.properties = referenceType.properties.concat(properties);
-        return referenceType;
-    }
-    static getRefTypeName(name, utilityType) {
-        return encodeURIComponent(name
-            .replace(/<|>/g, '_')
-            .replace(/\s+/g, '')
-            .replace(/,/g, '.')
-            .replace(/\'([^']*)\'/g, '$1')
-            .replace(/\"([^"]*)\"/g, '$1')
-            .replace(/&/g, typeof utilityType !== 'undefined' ? '--' : '-and-')
-            .replace(/\|/g, typeof utilityType !== 'undefined' ? '--' : '-or-')
-            .replace(/\[\]/g, '-array')
-            .replace(/{|}/g, '_') // SuccessResponse_{indexesCreated-number}_ -> SuccessResponse__indexesCreated-number__
-            .replace(/([a-z]+):([a-z]+)/gi, '$1-$2') // SuccessResponse_indexesCreated:number_ -> SuccessResponse_indexesCreated-number_
-            .replace(/;/g, '--')
-            .replace(/([a-z]+)\[([a-z]+)\]/gi, '$1-at-$2') // Partial_SerializedDatasourceWithVersion[format]_ -> Partial_SerializedDatasourceWithVersion~format~_,
-            .replace(/_/g, '')
-            .replace(/-/g, ''));
-    }
-    contextualizedName(name) {
-        return Object.entries(this.context).reduce((acc, [key, entry]) => acc
-            .replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `<$1${entry.getText()}$3>`)
-            .replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, 'g'), `<$1${entry.getText()}$3,`)
-            .replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `,$1${entry.getText()}$3>`)
-            .replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, 'g'), `<$1${entry.getText()}$3<`), name);
-    }
-    handleCachingAndCircularReferences(name, declarationResolver) {
-        try {
-            const existingType = localReferenceTypeCache[name];
-            if (existingType) {
-                return existingType;
-            }
-            if (inProgressTypes[name]) {
-                return this.createCircularDependencyResolver(name);
-            }
-            inProgressTypes[name] = true;
-            const reference = declarationResolver();
-            localReferenceTypeCache[name] = reference;
-            this.current.addReferenceType(reference);
-            return reference;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(`There was a problem resolving type of '${name}'.`);
-            throw err;
-        }
-    }
-    createCircularDependencyResolver(refName) {
-        const referenceType = {
-            typeName: 'refObject',
-            refName,
-        };
-        this.current.registerDependencyResolver((referenceTypes) => {
-            const realReferenceType = referenceTypes[refName];
-            if (!realReferenceType) {
-                return;
-            }
-            referenceType.description = realReferenceType.description;
-            if (realReferenceType.typeName === 'refObject' && referenceType.typeName === 'refObject') {
-                referenceType.properties = realReferenceType.properties;
-            }
-            referenceType.typeName = realReferenceType.typeName;
-            referenceType.refName = realReferenceType.refName;
-        });
-        return referenceType;
-    }
-    static nodeIsUsable(node) {
-        switch (node.kind) {
-            case ts.SyntaxKind.InterfaceDeclaration:
-            case ts.SyntaxKind.ClassDeclaration:
-            case ts.SyntaxKind.TypeAliasDeclaration:
-            case ts.SyntaxKind.EnumDeclaration:
-            case ts.SyntaxKind.EnumMember:
-                return true;
-            default:
-                return false;
-        }
-    }
-    // @ts-ignore
-    static resolveLeftmostIdentifier(type) {
-        while (type.kind !== ts.SyntaxKind.Identifier) {
-            type = type.left;
-        }
-        return type;
-    }
-    // @ts-ignore
-    static resolveRightMostIdentifier(type) {
-        while (type.kind !== ts.SyntaxKind.Identifier) {
-            type = type.right;
-        }
-        return type;
-    }
-    findMatchingModuleOrEnumDeclaration(statements, name) {
-        return statements.filter((node) => {
-            if ((node.kind !== ts.SyntaxKind.ModuleDeclaration || !this.current.isExportedNode(node)) && !ts.isEnumDeclaration(node)) {
-                return false;
-            }
-            const moduleDeclaration = node;
-            return moduleDeclaration.name.text.toLowerCase() === name.toLowerCase();
-        });
-    }
-    resolveModelTypeScope(leftmost, statements) {
-        while (leftmost.parent && leftmost.parent.kind === ts.SyntaxKind.QualifiedName) {
-            const leftmostName = leftmost.kind === ts.SyntaxKind.Identifier ? leftmost.text : leftmost.right.text;
-            const moduleDeclarations = this.findMatchingModuleOrEnumDeclaration(statements, leftmostName);
-            if (moduleDeclarations.length > 0) {
-                statements = Array.prototype.concat(...moduleDeclarations.map((declaration) => {
-                    if (ts.isEnumDeclaration(declaration)) {
-                        return declaration.members;
-                    }
-                    if (!declaration.body || !ts.isModuleBlock(declaration.body)) {
-                        throw new error_1.ResolverError(`Module declaration found for ${leftmostName} has no body.`);
-                    }
-                    return declaration.body.statements;
-                }));
-            }
-            leftmost = leftmost.parent;
-        }
-        return statements;
-    }
-    getModelTypeDeclaration(type) {
-        const leftmostIdentifier = TypeNodeResolver.resolveLeftmostIdentifier(type);
-        const statements = this.resolveModelTypeScope(leftmostIdentifier, this.current.nodes);
-        const typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
-        let modelTypes = statements.filter((node) => {
-            var _a;
-            if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) {
-                return false;
-            }
-            const modelTypeDeclaration = node;
-            return ((_a = modelTypeDeclaration.name) === null || _a === void 0 ? void 0 : _a.text) === typeName;
-        });
-        if (!modelTypes.length) {
-            throw new error_1.ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
-        }
-        if (modelTypes.length > 1) {
-            // remove types that are from typescript e.g. 'Account'
-            modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile().fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules') <= -1);
-            modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
-        }
-        if (modelTypes.length > 1) {
-            const conflicts = modelTypes.map((modelType) => modelType.getSourceFile().fileName).join('"; "');
-            throw new error_1.ResolverError(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
-        }
-        return modelTypes[0];
-    }
-    getModelProperties(node, overrideToken, utilityType, utilityOptions) {
-        const isIgnored = (e) => (0, utils_1.isExistJSDocTag)(e, (tag) => tag.tagName.text === 'ignore');
-        // Interface model
-        if (ts.isInterfaceDeclaration(node)) {
-            return node.members.filter((member) => !isIgnored(member) && ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
-        }
-        // Class model
-        let properties = node.members
-            .filter((member) => !isIgnored(member))
-            .filter((member) => member.kind === ts.SyntaxKind.PropertyDeclaration)
-            .filter((member) => !this.hasStaticModifier(member))
-            .filter((member) => this.hasPublicModifier(member));
-        const classConstructor = node.members.find((member) => ts.isConstructorDeclaration(member));
-        if (classConstructor && classConstructor.parameters) {
-            const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
-            properties.push(...constructorProperties);
-        }
-        properties = this.filterUtilityProperties(properties, utilityType, utilityOptions);
-        return properties.map((property) => this.propertyFromDeclaration(property, overrideToken, utilityType));
-    }
-    propertyFromSignature(propertySignature, overrideToken) {
-        const identifier = propertySignature.name;
-        if (!propertySignature.type) {
-            throw new error_1.ResolverError('No valid type found for property declaration.');
-        }
-        let required = !propertySignature.questionToken;
-        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
-            required = true;
-        }
-        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
-            required = false;
-        }
-        const property = {
-            deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, (tag) => tag.tagName.text === 'deprecated'),
-            default: (0, utils_1.getJSDocTagComment)(propertySignature, 'default'),
-            description: this.getNodeDescription(propertySignature),
-            example: TypeNodeResolver.getNodeExample(propertySignature),
-            format: TypeNodeResolver.getNodeFormat(propertySignature),
-            name: identifier.text,
-            required,
-            type: new TypeNodeResolver(propertySignature.type, this.current, propertySignature.type.parent, this.context, propertySignature.type).resolve(),
-            validators: getPropertyValidators(propertySignature) || {},
-        };
-        return property;
-    }
-    propertyFromDeclaration(propertyDeclaration, overrideToken, utilityType) {
-        const identifier = propertyDeclaration.name;
-        let typeNode = propertyDeclaration.type;
-        if (!typeNode) {
-            const tsType = this.current.typeChecker.getTypeAtLocation(propertyDeclaration);
-            typeNode = this.current.typeChecker.typeToTypeNode(tsType, undefined, ts.NodeBuilderFlags.NoTruncation);
-        }
-        if (!typeNode) {
-            throw new error_1.ResolverError('No valid type found for property declaration.');
-        }
-        const type = new TypeNodeResolver(typeNode, this.current, propertyDeclaration, this.context, typeNode).resolve();
-        let required = !propertyDeclaration.questionToken && !propertyDeclaration.initializer;
-        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
-            required = true;
-        }
-        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
-            required = false;
-        }
-        if (typeof utilityType !== 'undefined') {
-            if (utilityType === 'Partial') {
-                required = false;
-            }
-            if (utilityType === 'Required') {
-                required = true;
-            }
-        }
-        const property = {
-            deprecated: (0, utils_1.isExistJSDocTag)(propertyDeclaration, (tag) => tag.tagName.text === 'deprecated'),
-            default: (0, utils_2.getInitializerValue)(propertyDeclaration.initializer, this.current.typeChecker),
-            description: this.getNodeDescription(propertyDeclaration),
-            example: TypeNodeResolver.getNodeExample(propertyDeclaration),
-            format: TypeNodeResolver.getNodeFormat(propertyDeclaration),
-            name: identifier.text,
-            required,
-            type,
-            validators: getPropertyValidators(propertyDeclaration) || {},
-        };
-        return property;
-    }
-    getModelAdditionalProperties(node) {
-        if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
-            const indexMember = node.members.find((member) => member.kind === ts.SyntaxKind.IndexSignature);
-            if (!indexMember) {
-                return undefined;
-            }
-            const indexSignatureDeclaration = indexMember;
-            const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-            if (indexType.typeName !== 'string') {
-                throw new error_1.ResolverError('Only string indexers are supported.', this.typeNode);
-            }
-            return new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
-        }
-        return undefined;
-    }
-    typeArgumentsToContext(type, targetEntity, context) {
-        // this.context = {};
-        const declaration = this.getModelTypeDeclaration(targetEntity);
-        const typeParameters = 'typeParameters' in declaration ? declaration.typeParameters : undefined;
-        if (typeParameters) {
-            for (let index = 0; index < typeParameters.length; index++) {
-                const typeParameter = typeParameters[index];
-                const typeArg = type.typeArguments && type.typeArguments[index];
-                let resolvedType;
-                // Argument may be a forward reference from context
-                if (typeArg && ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && context[typeArg.typeName.text]) {
-                    resolvedType = context[typeArg.typeName.text];
-                }
-                else if (typeArg) {
-                    resolvedType = typeArg;
-                }
-                else if (typeParameter.default) {
-                    resolvedType = typeParameter.default;
-                }
-                else {
-                    throw new error_1.ResolverError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
-                }
-                this.context = Object.assign(Object.assign({}, this.context), { [typeParameter.name.text]: resolvedType });
-            }
-        }
-        return context;
-    }
-    getModelInheritedProperties(modelTypeDeclaration) {
-        let properties = [];
-        const { heritageClauses } = modelTypeDeclaration;
-        if (!heritageClauses) {
-            return properties;
-        }
-        heritageClauses.forEach((clause) => {
-            if (!clause.types) {
-                return;
-            }
-            clause.types.forEach((t) => {
-                const baseEntityName = t.expression;
-                // create subContext
-                const resetCtx = this.typeArgumentsToContext(t, baseEntityName, this.context);
-                const referenceType = this.getReferenceType(t);
-                if (referenceType) {
-                    if (referenceType.typeName === 'refEnum') {
-                        // since it doesn't have properties to iterate over, then we don't do anything with it
-                    }
-                    else if (referenceType.typeName === 'refAlias') {
-                        let type = referenceType;
-                        while (type.typeName === 'refAlias') {
-                            type = type.type;
-                        }
-                        if (type.typeName === 'refObject') {
-                            properties = [...properties, ...type.properties];
-                        }
-                        else if (type.typeName === 'nestedObjectLiteral') {
-                            properties = [...properties, ...type.properties];
-                        }
-                    }
-                    else if (referenceType.typeName === 'refObject') {
-                        referenceType.properties.forEach((property) => properties.push(property));
-                    }
-                    else {
-                        // todo: should never assert
-                    }
-                }
-                // reset subContext
-                this.context = resetCtx;
-            });
-        });
-        return properties;
-    }
-    hasPublicModifier(node) {
-        return (!node.modifiers ||
-            node.modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword));
-    }
-    hasStaticModifier(node) {
-        return (node.modifiers &&
-            node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
-    }
-    isAccessibleParameter(node) {
-        // No modifiers
-        if (!node.modifiers) {
-            return false;
-        }
-        // public || public readonly
-        if (node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
-            return true;
-        }
-        // readonly, not private readonly, not public readonly
-        const isReadonly = node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
-        const isProtectedOrPrivate = node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ProtectedKeyword || modifier.kind === ts.SyntaxKind.PrivateKeyword);
-        return isReadonly && !isProtectedOrPrivate;
-    }
-    getNodeDescription(node) {
-        const symbol = this.current.typeChecker.getSymbolAtLocation(node.name);
-        if (!symbol) {
-            return undefined;
-        }
-        /**
-         * TODO: Workaround for what seems like a bug in the compiler
-         * Warrants more investigation and possibly a PR against typescript
-         */
-        if (node.kind === ts.SyntaxKind.Parameter) {
-            // TypeScript won't parse jsdoc if the flag is 4, i.e. 'Property'
-            symbol.flags = 0;
-        }
-        const comments = symbol.getDocumentationComment(this.current.typeChecker);
-        if (comments.length) {
-            return ts.displayPartsToString(comments);
-        }
-        return undefined;
-    }
-    static getNodeFormat(node) {
-        return (0, utils_1.getJSDocTagComment)(node, 'format');
-    }
-    static getNodeExample(node) {
-        const example = (0, utils_1.getJSDocTagComment)(node, 'example');
-        if (example) {
-            try {
-                return JSON.parse(example);
-            }
-            catch (_a) {
-                return undefined;
-            }
-        }
-        else {
-            return undefined;
-        }
-    }
-}
-exports.TypeNodeResolver = TypeNodeResolver;
-//# sourceMappingURL=type-node.js.map