@vkontakte/api-schema-typescript-generator 0.9.0 → 0.13.0

package/dist/generator.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStandaloneEnum = exports.generateInlineEnum = exports.generateImportsBlock = void 0;
-const types_1 = require("./types");
-const utils_1 = require("./utils");
+exports.generateImportsBlock = void 0;
 const constants_1 = require("./constants");
 const helpers_1 = require("./helpers");
-const TypeCodeBlock_1 = require("./generators/TypeCodeBlock");
-function generateImportsBlock(imports, section, type) {
-    const objectsToImport = utils_1.uniqueArray(Object.keys(imports));
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+function generateImportsBlock(refs, section, type) {
+    let importRefs = Object.entries(refs)
+        .filter(([, type]) => type === types_1.RefsDictionaryType.GenerateAndImport)
+        .map(([key]) => key);
+    importRefs = utils_1.uniqueArray(importRefs);
     const paths = {};
-    objectsToImport.forEach((objectName) => {
+    importRefs.forEach((objectName) => {
         const importSection = helpers_1.getSectionFromObjectName(objectName);
         const interfaceName = helpers_1.getInterfaceName(objectName);
         let path;
@@ -37,95 +39,3 @@ function generateImportsBlock(imports, section, type) {
     return importLines.join(constants_1.newLineChar);
 }
 exports.generateImportsBlock = generateImportsBlock;
-function getEnumNames(object) {
-    let { enumNames } = object;
-    const needEnumNamesDescription = !!enumNames;
-    if (!enumNames) {
-        const canUseEnumNames = !object.enum.some((value) => !!+value);
-        if (canUseEnumNames) {
-            enumNames = [...object.enum];
-        }
-    }
-    return {
-        needEnumNamesDescription,
-        enumNames: Array.isArray(enumNames) && enumNames.length ? enumNames : undefined,
-    };
-}
-function generateInlineEnum(object, options = {}) {
-    const { enumNames, needEnumNamesDescription, } = getEnumNames(object);
-    const codeBlocks = [];
-    let descriptionLines = [];
-    if (enumNames) {
-        const enumName = options.objectParentName ? `${options.objectParentName} ${object.name} enumNames` : object.name;
-        const enumInterfaceName = helpers_1.getInterfaceName(enumName);
-        const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
-            type: TypeCodeBlock_1.TypeScriptCodeTypes.ConstantObject,
-            refName: enumName,
-            interfaceName: enumInterfaceName,
-            needExport: true,
-            properties: [],
-        });
-        if (needEnumNamesDescription) {
-            descriptionLines.push('');
-        }
-        enumNames.forEach((name, index) => {
-            const value = object.enum[index];
-            codeBlock.addProperty({
-                name: helpers_1.getEnumPropertyName(name.toString()),
-                value,
-                wrapValue: true,
-            });
-            if (needEnumNamesDescription) {
-                descriptionLines.push(`\`${value}\` — ${name}`);
-            }
-        });
-        if (!options.skipEnumNamesConstant) {
-            codeBlocks.push(codeBlock);
-        }
-    }
-    const values = object.enum.map((value) => utils_1.quoteJavaScriptValue(value));
-    return {
-        codeBlocks,
-        imports: {},
-        value: helpers_1.joinOneOfValues(values, true),
-        description: descriptionLines.join(constants_1.newLineChar),
-    };
-}
-exports.generateInlineEnum = generateInlineEnum;
-function generateStandaloneEnum(object, options = {}) {
-    const { enumNames, } = getEnumNames(object);
-    if (enumNames) {
-        const enumName = options.objectParentName ? `${options.objectParentName} ${object.name} enum` : object.name;
-        const enumInterfaceName = helpers_1.getInterfaceName(enumName);
-        const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
-            type: TypeCodeBlock_1.TypeScriptCodeTypes.Enum,
-            refName: enumName,
-            interfaceName: enumInterfaceName,
-            needExport: true,
-            properties: [],
-        });
-        enumNames.forEach((name, index) => {
-            codeBlock.addProperty({
-                name: helpers_1.getEnumPropertyName(name.toString()),
-                value: object.enum[index],
-                wrapValue: true,
-            });
-        });
-        return {
-            codeBlocks: [
-                codeBlock,
-            ],
-            imports: {},
-            value: enumInterfaceName,
-        };
-    }
-    else {
-        const values = object.enum.map((value) => utils_1.quoteJavaScriptValue(value));
-        return {
-            codeBlocks: [],
-            imports: {},
-            value: helpers_1.joinOneOfValues(values, true),
-        };
-    }
-}
-exports.generateStandaloneEnum = generateStandaloneEnum;

package/dist/generators/APITypingsGenerator.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APITypingsGenerator = void 0;
 const types_1 = require("../types");
+const enums_1 = require("./enums");
+const methods_1 = require("./methods");
 const SchemaObject_1 = require("./SchemaObject");
 const helpers_1 = require("../helpers");
 const TypeCodeBlock_1 = require("./TypeCodeBlock");
@@ -21,7 +23,7 @@ class APITypingsGenerator {
         this.outDirPath = options.outDirPath;
         this.methodsPattern = helpers_1.prepareMethodsPattern(options.methodsPattern);
         this.methodsDefinitions = options.methodsDefinitions;
-        this.methodsList = options.methodsDefinitions.methods;
+        this.methodsList = options.methodsDefinitions.methods || [];
         this.objects = this.convertJSONSchemaDictionary(options.objects);
         this.responses = this.convertJSONSchemaDictionary(options.responses);
         this.visitedRefs = {};
@@ -83,9 +85,11 @@ class APITypingsGenerator {
             if (allOfItem.ref && !this.visitedRefs[allOfItem.ref]) {
                 this.visitedRefs[allOfItem.ref] = true;
                 const refName = allOfItem.ref;
-                const objectName = helpers_1.getObjectNameByRef(refName);
-                allOfItem = this.objects[objectName];
-                if (!allOfItem) {
+                const tempAllOfItem = this.getObjectByRef(refName);
+                if (tempAllOfItem) {
+                    allOfItem = tempAllOfItem;
+                }
+                else {
                     log_1.consoleLogErrorAndExit(`${refName} ref not found`);
                 }
             }
@@ -108,10 +112,10 @@ class APITypingsGenerator {
                     additionalProperties = allOfItem.properties;
                 }
                 else if (allOfItem.ref) {
-                    const objectName = helpers_1.getObjectNameByRef(allOfItem.ref);
-                    const refObject = this.objects[objectName];
+                    const refObject = this.getObjectByRef(allOfItem.ref);
                     if (!refObject) {
                         log_1.consoleLogErrorAndExit(`${object.name} ref object in allOf is not found`);
+                        return;
                     }
                     additionalProperties = this.getObjectProperties(refObject, deep + 1);
                 }
@@ -130,7 +134,7 @@ class APITypingsGenerator {
             return properties;
         }
     }
-    /*
+    /**
      * Filter properties with same name
      * If an object uses allOf, some nested objects may have the same properties
      */
@@ -150,7 +154,6 @@ class APITypingsGenerator {
         let imports = {};
         let codeBlocks = [];
         const properties = this.getObjectProperties(object);
-        const requiredProperties = utils_1.arrayToMap(object.required);
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
             refName: object.name,
@@ -163,14 +166,16 @@ class APITypingsGenerator {
             return this.getPrimitiveInterfaceCode(object);
         }
         properties.forEach((property) => {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, description, } = typeString_1.generateTypeString(property, this.objects);
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, description, } = typeString_1.generateTypeString(property, this.objects, {
+                objectParentName: object.name,
+            });
             imports = { ...imports, ...newImports };
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
             codeBlock.addProperty({
                 name: property.name,
                 description: [property.description, description].join(constants_1.newLineChar),
                 value,
-                isRequired: helpers_1.isPatternProperty(property.name) || requiredProperties[property.name],
+                isRequired: helpers_1.isPatternProperty(property.name) || property.isRequired,
             });
         });
         return {
@@ -187,7 +192,7 @@ class APITypingsGenerator {
             return this.getObjectCodeBlockAsType(object);
         }
         if (object.enum) {
-            const { codeBlocks } = generator_1.generateStandaloneEnum(object);
+            const { codeBlocks } = enums_1.generateEnumAsUnionType(object);
             return {
                 codeBlocks: codeBlocks,
                 imports: {},
@@ -243,10 +248,13 @@ class APITypingsGenerator {
         });
         this.generateObjectsFromImports(imports);
     }
+    getObjectByRef(ref) {
+        const refName = helpers_1.getObjectNameByRef(ref);
+        return this.objects[refName];
+    }
     generateObjectsFromRefs(refs) {
         Object.keys(refs).forEach((ref) => {
-            const refName = helpers_1.getObjectNameByRef(ref);
-            const refObject = this.objects[refName];
+            const refObject = this.getObjectByRef(ref);
             if (!refObject) {
                 log_1.consoleLogInfo(`"${ref}" ref is not found`);
                 return;
@@ -256,8 +264,7 @@ class APITypingsGenerator {
     }
     generateObjectsFromImports(imports) {
         Object.keys(imports).forEach((ref) => {
-            const refName = helpers_1.getObjectNameByRef(ref);
-            const refObject = this.objects[refName];
+            const refObject = this.getObjectByRef(ref);
             if (!refObject) {
                 log_1.consoleLogInfo(`"${ref}" ref is not found`);
                 return;
@@ -268,39 +275,6 @@ class APITypingsGenerator {
     generateMethodParams(methodInfo) {
         const section = helpers_1.getMethodSection(methodInfo.name);
         const interfaceName = `${methodInfo.name} params`;
-        const parametersRaw = Array.isArray(methodInfo.parameters) ? methodInfo.parameters : [];
-        const requiredParams = parametersRaw.reduce((acc, param) => {
-            if (param.required) {
-                acc[param.name] = true;
-            }
-            return acc;
-        }, {});
-        const properties = parametersRaw.map((paramRaw) => {
-            paramRaw = { ...paramRaw };
-            // For method params "boolean" type means 1 or 0
-            // Real "false" boolean value will be detected by API as true
-            if (paramRaw.type === 'boolean') {
-                delete paramRaw.type;
-                paramRaw.$ref = constants_1.baseBoolIntRef;
-            }
-            // For parameters of the "array" type, VK API still accepts only a comma-separated string
-            // This may change in the future when the VK API starts accepting a json body
-            if (paramRaw.type === 'array') {
-                paramRaw.type = 'string';
-                if (!paramRaw.description) {
-                    paramRaw.description = '';
-                }
-                if (paramRaw.items) {
-                    if (paramRaw.items.$ref) {
-                        this.generateObjectsFromRefs({
-                            [paramRaw.items.$ref]: true,
-                        });
-                        paramRaw.description += constants_1.newLineChar.repeat(2) + paramRaw.items.$ref;
-                    }
-                }
-            }
-            return new SchemaObject_1.SchemaObject(paramRaw.name, paramRaw, interfaceName);
-        });
         let imports = {};
         let codeBlocks = [];
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
@@ -310,35 +284,32 @@ class APITypingsGenerator {
             allowEmptyInterface: true,
             properties: [],
         });
-        properties.forEach((property) => {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(property, this.objects, { skipEnumNamesConstant: true });
+        methodInfo.parameters.forEach((property) => {
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(property, this.objects, { needEnumNamesConstant: false });
             imports = { ...imports, ...newImports };
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
             codeBlock.addProperty({
                 name: property.name,
                 description: property.description,
                 value,
-                isRequired: requiredParams[property.name],
+                isRequired: property.isRequired,
             });
         });
         this.appendToFileMap(section, imports, [...codeBlocks, codeBlock]);
         this.generateObjectsFromImports(imports);
     }
-    getResponseObjectRef(object) {
-        const objectName = helpers_1.getObjectNameByRef(object.ref);
+    getResponseObjectRef(ref) {
+        const objectName = helpers_1.getObjectNameByRef(ref);
         if (this.responses[objectName]) {
             return this.responses[objectName];
         }
-        else if (this.objects[objectName]) {
-            return this.objects[objectName];
-        }
-        return undefined;
+        return this.getObjectByRef(ref);
     }
     getObjectCodeBlockAsType(object) {
         let codeBlocks = [];
         let imports = {};
         if (object.enum) {
-            const { codeBlocks: newCodeBlocks } = generator_1.generateStandaloneEnum(object);
+            const { codeBlocks: newCodeBlocks } = enums_1.generateEnumAsUnionType(object);
             codeBlocks = [
                 ...newCodeBlocks,
             ];
@@ -368,36 +339,29 @@ class APITypingsGenerator {
         };
     }
     getResponseCodeBlockAsType(object, response) {
-        let codeBlocks = [];
-        let imports = {};
-        if (response.enum) {
-            const { codeBlocks: newCodeBlocks } = generator_1.generateStandaloneEnum(response);
-            codeBlocks = [
-                ...newCodeBlocks,
-            ];
-        }
-        else {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks } = typeString_1.generateTypeString(response, this.objects);
-            const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
-                type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
-                refName: object.name,
-                interfaceName: helpers_1.getInterfaceName(object.name),
-                description: object.description,
-                needExport: true,
-                properties: [],
-                value,
-            });
-            imports = newImports;
-            codeBlocks = [
+        const { imports, value, codeBlocks, description, } = typeString_1.generateTypeString(response, this.objects, {
+            objectParentName: ' ',
+        });
+        const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+            refName: object.name,
+            interfaceName: helpers_1.getInterfaceName(object.name),
+            description: [
+                object.description,
+                description || '',
+            ].join(constants_1.newLineChar),
+            needExport: true,
+            properties: [],
+            value,
+        });
+        return {
+            codeBlocks: [
                 ...codeBlocks,
-                ...newCodeBlocks,
                 codeBlock,
-            ];
-        }
-        return {
-            codeBlocks,
+            ],
             imports,
             value: '',
+            description,
         };
     }
     getResponseCodeBlock(object) {
@@ -411,62 +375,35 @@ class APITypingsGenerator {
             [constants_1.basePropertyExistsRef]: true,
         };
         const objectName = helpers_1.getObjectNameByRef(object.ref);
-        let response;
         if (nonBuildableRefs[objectName]) {
             return this.getObjectCodeBlockAsType(object);
         }
-        else if (this.responses[objectName]) {
-            response = this.responses[objectName];
-            const { properties = [] } = response;
-            const responseProperty = properties.find((property) => property.name === 'response');
-            if (responseProperty) {
-                response = responseProperty;
-                if (response.ref) {
-                    return this.getResponseCodeBlockAsType(object, response);
-                }
-            }
-            else {
-                // Maybe this is a crutch?
-                response.properties.forEach((property) => {
-                    if (response && property.parentObjectName === response.name) {
-                        response = property;
-                        return true;
-                    }
-                    return false;
-                });
-            }
-        }
-        else if (this.objects[objectName]) {
-            response = this.objects[objectName];
-            if (object.ref) {
-                return this.getResponseCodeBlockAsType(object, object);
-            }
-        }
-        // @ts-ignore
-        while (response && response.ref) {
-            response = this.getResponseObjectRef(response);
-        }
+        let response = this.getResponseObjectRef(object.ref);
         if (!response) {
-            log_1.consoleLogErrorAndExit(`"${object.name}" has no response`);
+            log_1.consoleLogError(`response schema object "${object.name}" has no response`, object);
             return false;
         }
-        response.originalName = response.name;
+        // VK API JSON Schema specific heuristic
+        if (response.properties.length === 1 && response.properties[0].name === 'response') {
+            response = response.properties[0];
+        }
+        if (response.ref) {
+            return this.getResponseCodeBlockAsType(object, response);
+        }
+        response = response.clone();
         response.setName(object.name);
-        let result;
         switch (response.type) {
             case 'object':
-                result = this.getObjectInterfaceCode(response);
-                break;
+                return this.getObjectInterfaceCode(response);
             case 'integer':
             case 'string':
             case 'boolean':
             case 'array':
                 return this.getResponseCodeBlockAsType(object, response);
             default:
-                log_1.consoleLogErrorAndExit(response.name, 'unknown type');
+                log_1.consoleLogErrorAndExit(response.name, 'unknown type', response.type);
                 return false;
         }
-        return result;
     }
     generateResponse(section, response) {
         const result = this.getResponseCodeBlock(response);
@@ -477,33 +414,36 @@ class APITypingsGenerator {
         this.appendToFileMap(section, imports, codeBlocks);
         this.generateObjectsFromImports(imports);
     }
-    generateMethodParamsAndResponses(methodInfo) {
-        const { name } = methodInfo;
-        const section = helpers_1.getMethodSection(name);
-        if (!utils_1.isObject(methodInfo.responses)) {
-            log_1.consoleLogErrorAndExit(`"${name}" "responses" field is not an object.`);
+    generateMethodParamsAndResponses(method) {
+        const { name: methodName } = method;
+        const section = helpers_1.getMethodSection(methodName);
+        if (!utils_1.isObject(method.responses)) {
+            log_1.consoleLogErrorAndExit(`"${methodName}" "responses" field is not an object.`);
             return;
         }
-        if (Object.keys(methodInfo.responses).length === 0) {
-            log_1.consoleLogErrorAndExit(`"${name}" "responses" field is empty.`);
+        if (Object.keys(method.responses).length === 0) {
+            log_1.consoleLogErrorAndExit(`"${methodName}" "responses" field is empty.`);
             return;
         }
         // Comment with method name for visual sections in file
-        const methodNameComment = new CommentCodeBlock_1.CommentCodeBlock([name]);
-        if (methodInfo.description) {
+        const methodNameComment = new CommentCodeBlock_1.CommentCodeBlock([methodName]);
+        if (method.description) {
             methodNameComment.appendLines([
                 '',
-                methodInfo.description,
+                method.description,
             ]);
         }
         this.appendToFileMap(section, {}, [methodNameComment]);
-        this.generateMethodParams(methodInfo);
-        Object.entries(methodInfo.responses).forEach(([responseName, responseObject]) => {
-            if (this.ignoredResponses[name] && this.ignoredResponses[name][responseName]) {
+        const { method: normalizedMethod, parameterRefs, } = methods_1.normalizeMethodInfo(method);
+        method = normalizedMethod;
+        this.generateObjectsFromRefs(parameterRefs);
+        this.generateMethodParams(new SchemaObject_1.SchemaObject(method.name, method));
+        Object.entries(method.responses).forEach(([responseName, responseObject]) => {
+            if (this.ignoredResponses[methodName] && this.ignoredResponses[methodName][responseName]) {
                 return;
             }
-            responseObject.name = `${name}_${responseName}`;
-            this.generateResponse(section, new SchemaObject_1.SchemaObject(responseObject.name, responseObject));
+            const name = `${methodName}_${responseName}`;
+            this.generateResponse(section, new SchemaObject_1.SchemaObject(name, responseObject));
         });
     }
     generateMethods() {

package/dist/generators/SchemaObject.js

@@ -38,12 +38,21 @@ class SchemaObject {
         else {
             this.required = [];
         }
+        if (typeof object.required === 'boolean') {
+            this.isRequired = object.required;
+        }
         this.properties = [];
         if (object.properties) {
             Object.entries(object.properties).forEach(([propertyName, property]) => {
                 this.properties.push(new SchemaObject(propertyName, property, name));
             });
         }
+        this.parameters = [];
+        if (Array.isArray(object.parameters)) {
+            object.parameters.forEach((parameter) => {
+                this.parameters.push(new SchemaObject(parameter.name, parameter, `${name} param`));
+            });
+        }
         if (object.patternProperties) {
             Object.entries(object.patternProperties).forEach(([propertyName, property]) => {
                 this.properties.push(new SchemaObject(helpers_1.transformPatternPropertyName(propertyName), property, name));
@@ -58,17 +67,17 @@ class SchemaObject {
         if (Array.isArray(object.allOf) && object.allOf.length > 0) {
             this.allOf = object.allOf.map((item) => new SchemaObject(name, item));
         }
-        // Crutch
-        // if (this.oneOf && this.oneOf.length === 1) {
-        //   this.allOf = [this.oneOf[0]];
-        //   this.oneOf = undefined;
-        // }
     }
     setName(name) {
         this.name = name;
         if (Array.isArray(this.properties)) {
-            this.properties.forEach((property) => property.parentObjectName = name);
+            this.properties.forEach((property) => {
+                property.parentObjectName = name;
+            });
         }
     }
+    clone() {
+        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    }
 }
 exports.SchemaObject = SchemaObject;

package/dist/generators/TypeCodeBlock.js

@@ -52,15 +52,11 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
             let propertyCode = [
                 `  ${quoteChar}${property.name}${quoteChar}${divider} ${value}${lineEnd}`,
             ];
-            const propertyDescriptionLines = utils_1.trimArray((property.description || '').trim().split(constants_1.newLineChar));
-            if (propertyDescriptionLines.length) {
-                propertyCode.unshift([
-                    '  /**',
-                    ...propertyDescriptionLines.map((line) => {
-                        return '   ' + `* ${line}`.trim();
-                    }),
-                    '   */',
-                ].join(constants_1.newLineChar));
+            if (property.description) {
+                const commentLines = helpers_1.joinCommentLines(2, property.description);
+                if (commentLines.length) {
+                    propertyCode.unshift(commentLines.join(constants_1.newLineChar));
+                }
             }
             return propertyCode.join(constants_1.newLineChar);
         }).join(constants_1.newLineChar);
@@ -71,16 +67,15 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
         let propertiesCode = this.getPropertiesCode();
         let before = [];
         let code = '';
+        if (this.refName) {
+            before.push(`// ${this.refName}`);
+        }
         if (this.description) {
             before = [
-                '/**',
-                ` * ${this.description}`,
-                ' */',
+                ...before,
+                ...helpers_1.joinCommentLines(0, this.description),
             ];
         }
-        if (this.refName) {
-            before.push(`// ${this.refName}`);
-        }
         switch (this.type) {
             case TypeScriptCodeTypes.Interface: {
                 if (!hasProperties) {