@vkontakte/api-schema-typescript-generator/dist/generators/typeString.js

VK API TypeScript generator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateTypeString = void 0;
const constants_1 = require("../constants");
const enums_1 = require("./enums");
const helpers_1 = require("../helpers");
const log_1 = require("../log");
const types_1 = require("../types");
const utils_1 = require("../utils");
const mergeImports_1 = require("./utils/mergeImports");
function generateBaseType(object, options) {
    let codeBlocks = [];
    let typeString = 'any /* default type */';
    let imports = {};
    let description = '';
    if (object.enum) {
        const { value, codeBlocks: newCodeBlocks, description: newDescription, } = (0, enums_1.generateInlineEnum)(object, {
            // TODO: Refactor
            // section_object_name -> property_name -> items => section_object_name_property_name_items enumNames
            objectParentName: options.objectParentName || object.parentObjectName,
            needEnumNamesConstant: options.needEnumNamesConstant,
        });
        typeString = value;
        codeBlocks = newCodeBlocks;
        description = newDescription;
    }
    else if ((0, utils_1.isString)(object.type)) {
        const primitive = constants_1.primitiveTypes[object.type];
        if (!primitive) {
            (0, log_1.consoleLogErrorAndExit)(object.name, `Error, type "${object.type}" is not declared type`);
        }
        typeString = primitive;
    }
    else if (Array.isArray(object.type)) {
        const primitivesTypesArray = (0, helpers_1.resolvePrimitiveTypesArray)(object.type);
        if (primitivesTypesArray !== null) {
            typeString = primitivesTypesArray;
        }
    }
    return {
        codeBlocks,
        imports,
        value: typeString,
        description,
    };
}
function generateTypeString(object, objects, options = {}) {
    let codeBlocks = [];
    let typeString = 'any /* default type */';
    let imports = {};
    let description = '';
    options = {
        needEnumNamesConstant: true,
        ...options,
    };
    if (object.oneOf) {
        const values = object.oneOf.map((oneOfObject) => {
            const { value, imports: newImports } = generateTypeString(oneOfObject, objects);
            imports = (0, mergeImports_1.mergeImports)(imports, newImports);
            return value;
        });
        typeString = (0, helpers_1.joinOneOfValues)(values);
    }
    else if (object.type === constants_1.PropertyType.ARRAY && object.items) {
        let depth = 1;
        let items = object.items;
        // Nested arrays
        while (true) {
            if (items.items) {
                items = items.items;
                depth++;
            }
            else {
                break;
            }
        }
        if (items.ref) {
            const refName = (0, helpers_1.getObjectNameByRef)(items.ref);
            const refObject = objects[refName];
            if (!refObject) {
                (0, log_1.consoleLogErrorAndExit)(`Error, object for "${refName}" ref is not found.`);
            }
            imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
            typeString = (0, helpers_1.formatArrayDepth)((0, helpers_1.getInterfaceName)(refName), depth);
        }
        else {
            const { value, description: newDescription, imports: newImports, codeBlocks: newCodeBlocks, } = generateBaseType(items, {
                ...options,
                // TODO: Refactor
                objectParentName: object.parentObjectName,
            });
            typeString = (0, helpers_1.formatArrayDepth)(value, depth);
            description = newDescription;
            imports = (0, mergeImports_1.mergeImports)(imports, newImports);
            codeBlocks = [...codeBlocks, ...newCodeBlocks];
        }
    }
    else if (object.ref) {
        const refName = (0, helpers_1.getObjectNameByRef)(object.ref);
        switch (refName) {
            case constants_1.baseOkResponseRef:
            case constants_1.basePropertyExistsRef:
                typeString = '1';
                break;
            case constants_1.baseBoolIntRef:
                typeString = '0 | 1';
                break;
            default: {
                const refObject = objects[refName];
                if (!refObject) {
                    (0, log_1.consoleLogErrorAndExit)(`Error, object for "${refName}" ref is not found.`);
                }
                if (refObject.enum) {
                    imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
                    typeString = (0, helpers_1.getInterfaceName)(refName);
                }
                else if (refObject.oneOf) {
                    const values = refObject.oneOf.map((oneOfObject) => {
                        const { value, imports: newImports } = generateTypeString(oneOfObject, objects);
                        imports = (0, mergeImports_1.mergeImports)(imports, newImports);
                        return value;
                    });
                    typeString = (0, helpers_1.joinOneOfValues)(values);
                }
                else if ((0, utils_1.isString)(refObject.type) && constants_1.scalarTypes[refObject.type] && !refObject.ref) {
                    typeString = constants_1.scalarTypes[refObject.type];
                }
                else if (object.type === constants_1.PropertyType.STRING) {
                    imports[refName] = types_1.RefsDictionaryType.Generate;
                    typeString = constants_1.scalarTypes.string;
                }
                else {
                    imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
                    typeString = (0, helpers_1.getInterfaceName)(refName);
                }
            }
        }
    }
    else if (object.type) {
        return generateBaseType(object, options);
    }
    return {
        codeBlocks,
        imports,
        value: typeString,
        description,
    };
}
exports.generateTypeString = generateTypeString;