@vkontakte/api-schema-typescript-generator 0.13.2 → 0.14.0

package/.eslintrc.json

@@ -24,6 +24,9 @@
     "@typescript-eslint/no-magic-numbers": "off",
     "@typescript-eslint/no-extra-parens": "off",
 
+    "@typescript-eslint/quotes": "off",
+    "@typescript-eslint/indent": "off",
+
     "no-shadow": "off"
   },
   "overrides": [

package/.prettierrc.js

@@ -0,0 +1,10 @@
+module.exports = {
+  printWidth: 100,
+  bracketSpacing: true,
+  bracketSameLine: false,
+  singleQuote: true,
+  trailingComma: 'all',
+  arrowParens: 'always',
+  semi: true,
+  quoteProps: 'consistent',
+};

package/dist/generators/APITypingsGenerator.js

@@ -26,13 +26,14 @@ class APITypingsGenerator {
         this.methodsList = options.methodsDefinitions.methods || [];
         this.objects = this.convertJSONSchemaDictionary(options.objects);
         this.responses = this.convertJSONSchemaDictionary(options.responses);
+        this.errors = options.errors;
         this.visitedRefs = {};
         this.generatedObjects = {};
         this.methodFilesMap = {};
         this.exports = {};
         this.ignoredResponses = {
             'storage.get': {
-                'keysResponse': true,
+                keysResponse: true,
             },
         };
         this.resultFiles = {};
@@ -44,6 +45,7 @@ class APITypingsGenerator {
     methodsList;
     objects;
     responses;
+    errors;
     visitedRefs;
     generatedObjects;
     methodFilesMap;
@@ -80,10 +82,7 @@ class APITypingsGenerator {
                 ...methodFile.imports,
                 ...imports,
             },
-            codeBlocks: [
-                ...methodFile.codeBlocks,
-                ...codeBlocks,
-            ],
+            codeBlocks: [...methodFile.codeBlocks, ...codeBlocks],
         };
     }
     collectAllOf(object, deep = 0) {
@@ -133,10 +132,7 @@ class APITypingsGenerator {
                     additionalProperties = this.getObjectProperties(refObject, deep + 1);
                 }
                 if (additionalProperties.length) {
-                    properties = [
-                        ...properties,
-                        ...additionalProperties,
-                    ];
+                    properties = [...properties, ...additionalProperties];
                 }
             });
         }
@@ -192,10 +188,7 @@ class APITypingsGenerator {
             });
         });
         return {
-            codeBlocks: [
-                ...codeBlocks,
-                codeBlock,
-            ],
+            codeBlocks: [...codeBlocks, codeBlock],
             imports,
             value: '',
         };
@@ -298,7 +291,9 @@ class APITypingsGenerator {
             properties: [],
         });
         methodInfo.parameters.forEach((property) => {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(property, this.objects, { needEnumNamesConstant: false });
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(property, this.objects, {
+                needEnumNamesConstant: false,
+            });
             imports = { ...imports, ...newImports };
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
             codeBlock.addProperty({
@@ -323,12 +318,10 @@ class APITypingsGenerator {
         let imports = {};
         if (object.enum) {
             const { codeBlocks: newCodeBlocks } = enums_1.generateEnumAsUnionType(object);
-            codeBlocks = [
-                ...newCodeBlocks,
-            ];
+            codeBlocks = [...newCodeBlocks];
         }
         else {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks } = typeString_1.generateTypeString(object, this.objects);
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(object, this.objects);
             const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
                 type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
                 refName: object.name,
@@ -339,11 +332,7 @@ class APITypingsGenerator {
                 value,
             });
             imports = newImports;
-            codeBlocks = [
-                ...codeBlocks,
-                ...newCodeBlocks,
-                codeBlock,
-            ];
+            codeBlocks = [...codeBlocks, ...newCodeBlocks, codeBlock];
         }
         return {
             codeBlocks,
@@ -352,26 +341,20 @@ class APITypingsGenerator {
         };
     }
     getResponseCodeBlockAsType(object, response) {
-        const { imports, value, codeBlocks, description, } = typeString_1.generateTypeString(response, this.objects, {
+        const { imports, value, codeBlocks, description } = typeString_1.generateTypeString(response, this.objects, {
             objectParentName: ' ', // TODO: Refactor
         });
         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),
+            description: [object.description, description || ''].join(constants_1.newLineChar),
             needExport: true,
             properties: [],
             value,
         });
         return {
-            codeBlocks: [
-                ...codeBlocks,
-                codeBlock,
-            ],
+            codeBlocks: [...codeBlocks, codeBlock],
             imports,
             value: '',
             description,
@@ -441,13 +424,10 @@ class APITypingsGenerator {
         // Comment with method name for visual sections in file
         const methodNameComment = new CommentCodeBlock_1.CommentCodeBlock([methodName]);
         if (method.description) {
-            methodNameComment.appendLines([
-                '',
-                method.description,
-            ]);
+            methodNameComment.appendLines(['', method.description]);
         }
         this.appendToFileMap(section, {}, [methodNameComment]);
-        const { method: normalizedMethod, parameterRefs, } = methods_1.normalizeMethodInfo(method);
+        const { method: normalizedMethod, parameterRefs } = methods_1.normalizeMethodInfo(method);
         method = normalizedMethod;
         this.generateObjectsFromRefs(parameterRefs);
         this.generateMethodParams(new SchemaObject_1.SchemaObject(method.name, method));
@@ -473,13 +453,35 @@ class APITypingsGenerator {
                     this.registerExport(`./methods/${section}`, codeBlock.interfaceName);
                 }
             });
-            const code = [
-                generator_1.generateImportsBlock(imports, null),
-                ...codeBlocks,
-            ];
+            const code = [generator_1.generateImportsBlock(imports, null), ...codeBlocks];
             this.registerResultFile(path_1.default.join('methods', `${section}.ts`), code.join(constants_1.newLineChar.repeat(2)));
         });
     }
+    generateErrors() {
+        log_1.consoleLogInfo('creating errors...');
+        const code = [];
+        Object.entries(this.errors)
+            .reduce((acc, [name, error]) => {
+            acc.push({ name, ...error });
+            return acc;
+        }, [])
+            .sort((errorA, errorB) => {
+            return errorA.code - errorB.code;
+        })
+            .forEach((error) => {
+            const errorConstantName = error.name.toUpperCase();
+            code.push(new TypeCodeBlock_1.TypeCodeBlock({
+                type: TypeCodeBlock_1.TypeScriptCodeTypes.Const,
+                interfaceName: errorConstantName,
+                needExport: true,
+                value: String(error.code),
+                properties: [],
+                description: [error.description, error.$comment || ''].join(constants_1.newLineChar.repeat(2)),
+            }).toString());
+            this.registerExport('./common/errors', errorConstantName);
+        });
+        this.registerResultFile(path_1.default.join('common', 'errors.ts'), code.join(constants_1.newLineChar.repeat(2)));
+    }
     createCommonTypes() {
         log_1.consoleLogInfo('creating common types...');
         const code = [];
@@ -545,6 +547,7 @@ class APITypingsGenerator {
     generate() {
         log_1.consoleLogInfo('generate');
         this.generateMethods();
+        this.generateErrors();
         if (this.needEmit) {
             this.createCommonTypes();
             this.createIndexExports();

package/dist/generators/CommentCodeBlock.js

@@ -10,18 +10,11 @@ class CommentCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
     }
     lines;
     appendLines(lines) {
-        this.lines = [
-            ...this.lines,
-            ...lines,
-        ];
+        this.lines = [...this.lines, ...lines];
     }
     toString() {
         const inner = this.lines.map((line) => constants_1.spaceChar + `* ${line}`.trim());
-        return [
-            '/**',
-            ...inner,
-            ' */',
-        ].join(constants_1.newLineChar);
+        return ['/**', ...inner, ' */'].join(constants_1.newLineChar);
     }
 }
 exports.CommentCodeBlock = CommentCodeBlock;

package/dist/generators/SchemaObject.js

@@ -7,7 +7,11 @@ const log_1 = require("../log");
 class SchemaObject {
     constructor(name, object, parentName) {
         if (!utils_1.isObject(object)) {
-            log_1.consoleLogErrorAndExit(`[SchemaObject] "${name}" is not an object.`, { name, object, parentName });
+            log_1.consoleLogErrorAndExit(`[SchemaObject] "${name}" is not an object.`, {
+                name,
+                object,
+                parentName,
+            });
             return;
         }
         this.name = name;

package/dist/generators/TypeCodeBlock.js

@@ -12,6 +12,7 @@ var TypeScriptCodeTypes;
     TypeScriptCodeTypes["Enum"] = "enum";
     TypeScriptCodeTypes["ConstantObject"] = "constant_object";
     TypeScriptCodeTypes["Type"] = "type";
+    TypeScriptCodeTypes["Const"] = "const";
 })(TypeScriptCodeTypes = exports.TypeScriptCodeTypes || (exports.TypeScriptCodeTypes = {}));
 class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
     constructor(options) {
@@ -39,8 +40,11 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
         this.properties.push(property);
     }
     getPropertiesCode() {
-        const quoteChar = this.properties.some((property) => helpers_1.areQuotesNeededForProperty(property.name)) ? '\'' : '';
-        return this.properties.map((property) => {
+        const quoteChar = this.properties.some((property) => helpers_1.areQuotesNeededForProperty(property.name))
+            ? "'"
+            : '';
+        return this.properties
+            .map((property) => {
             let divider = '';
             let lineEnd = '';
             switch (this.type) {
@@ -68,7 +72,8 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
                 }
             }
             return propertyCode.join(constants_1.newLineChar);
-        }).join(constants_1.newLineChar);
+        })
+            .join(constants_1.newLineChar);
     }
     toString() {
         const hasProperties = this.properties.length > 0;
@@ -80,10 +85,7 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
             before.push(`// ${this.refName}`);
         }
         if (this.description) {
-            before = [
-                ...before,
-                ...helpers_1.joinCommentLines(0, this.description),
-            ];
+            before = [...before, ...helpers_1.joinCommentLines(0, this.description)];
         }
         switch (this.type) {
             case TypeScriptCodeTypes.Interface: {
@@ -92,15 +94,12 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
                         propertiesCode = '';
                     }
                     else {
-                        propertiesCode = [
-                            '  // empty interface',
-                            '  [key: string]: any;',
-                        ].join(constants_1.newLineChar);
+                        propertiesCode = ['  // empty interface', '  [key: string]: any;'].join(constants_1.newLineChar);
                     }
                 }
-                const extendsInterfaces = Array.isArray(this.extendsInterfaces) && this.extendsInterfaces.length ?
-                    this.extendsInterfaces.join(', ') :
-                    '';
+                const extendsInterfaces = Array.isArray(this.extendsInterfaces) && this.extendsInterfaces.length
+                    ? this.extendsInterfaces.join(', ')
+                    : '';
                 code = [
                     utils_1.trimStringDoubleSpaces(`${exportKeyword} interface ${this.interfaceName} ${extendsInterfaces} {`),
                     propertiesCode,
@@ -130,11 +129,16 @@ class TypeCodeBlock extends BaseCodeBlock_1.BaseCodeBlock {
                     utils_1.trimStringDoubleSpaces(`${exportKeyword} type ${this.interfaceName} = ${this.value};`),
                 ].join(constants_1.newLineChar);
                 break;
+            case TypeScriptCodeTypes.Const:
+                if (!this.value) {
+                    log_1.consoleLogErrorAndExit(`"${this.interfaceName}" type has empty value`);
+                }
+                code = [
+                    utils_1.trimStringDoubleSpaces(`${exportKeyword} const ${this.interfaceName} = ${this.value};`),
+                ].join(constants_1.newLineChar);
+                break;
         }
-        return [
-            before.join(constants_1.newLineChar),
-            code,
-        ].join(constants_1.newLineChar).trim();
+        return [before.join(constants_1.newLineChar), code].join(constants_1.newLineChar).trim();
     }
 }
 exports.TypeCodeBlock = TypeCodeBlock;

package/dist/generators/enums.js

@@ -46,10 +46,7 @@ function generateEnumAsUnionType(object) {
         type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
         refName: object.name,
         interfaceName: helpers_1.getInterfaceName(object.name),
-        description: [
-            object.description,
-            description,
-        ].join(constants_1.newLineChar),
+        description: [object.description, description].join(constants_1.newLineChar),
         needExport: true,
         properties: [],
         value,
@@ -79,7 +76,7 @@ function getEnumNames(object) {
     };
 }
 function generateInlineEnum(object, options = {}) {
-    const { isNumericEnum, enumNames, needEnumNamesDescription, } = getEnumNames(object);
+    const { isNumericEnum, enumNames, needEnumNamesDescription } = getEnumNames(object);
     options = {
         needEnumNamesConstant: isNumericEnum,
         ...options,

package/dist/generators/methods.js

@@ -28,9 +28,9 @@ function normalizeMethodInfo(method) {
         if (parameter.items && parameter.items.$ref) {
             const ref = parameter.items?.$ref;
             parameterRefs[ref] = types_1.RefsDictionaryType.Generate;
-            parameter.description += constants_1.newLineChar.repeat(2) + [
-                `@see ${helpers_1.getInterfaceName(helpers_1.getObjectNameByRef(ref))} (${ref})`,
-            ].join(constants_1.newLineChar);
+            parameter.description +=
+                constants_1.newLineChar.repeat(2) +
+                    [`@see ${helpers_1.getInterfaceName(helpers_1.getObjectNameByRef(ref))} (${ref})`].join(constants_1.newLineChar);
         }
     });
     return {

package/dist/helpers.js

@@ -28,6 +28,7 @@ const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
 const constants_1 = require("./constants");
 const log_1 = require("./log");
+const prettier_1 = __importDefault(require("prettier"));
 async function readJSONFile(path) {
     const content = await fs_1.promises.readFile(path, 'utf-8');
     return JSON.parse(content);
@@ -54,15 +55,27 @@ function prepareBuildDirectory(directoryPath) {
 exports.prepareBuildDirectory = prepareBuildDirectory;
 function writeFile(filePath, code, insertAutoGeneratedNote = true) {
     if (insertAutoGeneratedNote) {
-        code = [
-            '/**',
-            ' * This is auto-generated file, don\'t modify this file manually',
-            ' */',
-            // '/* eslint-disable max-len */',
-            // '/* eslint-disable @typescript-eslint/no-empty-interface */',
-        ].join(constants_1.newLineChar) + constants_1.newLineChar.repeat(2) + code.trim();
+        code =
+            [
+                '/**',
+                " * This is auto-generated file, don't modify this file manually",
+                ' */',
+                // '/* eslint-disable max-len */',
+                // '/* eslint-disable @typescript-eslint/no-empty-interface */',
+            ].join(constants_1.newLineChar) +
+                constants_1.newLineChar.repeat(2) +
+                code.trim();
     }
-    fs_1.default.mkdirSync(filePath.replace(path_1.default.basename(filePath), ''), { recursive: true });
+    code = prettier_1.default.format(code, {
+        semi: true,
+        singleQuote: true,
+        trailingComma: 'all',
+        quoteProps: 'consistent',
+        parser: 'typescript',
+    });
+    fs_1.default.mkdirSync(filePath.replace(path_1.default.basename(filePath), ''), {
+        recursive: true,
+    });
     fs_1.default.writeFileSync(filePath, code.trim() + constants_1.newLineChar);
 }
 exports.writeFile = writeFile;
@@ -70,7 +83,10 @@ function prepareMethodsPattern(methodsPattern) {
     if (!methodsPattern) {
         log_1.consoleLogErrorAndExit('methodsPattern is empty. Pass "*" to generate all methods');
     }
-    return methodsPattern.replace(/\s+/g, '').split(',').reduce((acc, pattern) => {
+    return methodsPattern
+        .replace(/\s+/g, '')
+        .split(',')
+        .reduce((acc, pattern) => {
         acc[pattern] = true;
         return acc;
     }, {});
@@ -95,17 +111,16 @@ function getMethodSection(methodName) {
 }
 exports.getMethodSection = getMethodSection;
 function getInterfaceName(name) {
-    name = name.replace(/\.|(\s+)|_/g, ' ')
+    name = name
+        .replace(/\.|(\s+)|_/g, ' ')
         .split(' ')
-        .map((v) => utils_1.capitalizeFirstLetter(v)).join('');
+        .map((v) => utils_1.capitalizeFirstLetter(v))
+        .join('');
     return utils_1.capitalizeFirstLetter(name);
 }
 exports.getInterfaceName = getInterfaceName;
 function getEnumPropertyName(name) {
-    return name.toUpperCase()
-        .replace(/\s+/g, '_')
-        .replace(/-/g, '_')
-        .replace(/\./g, '_');
+    return name.toUpperCase().replace(/\s+/g, '_').replace(/-/g, '_').replace(/\./g, '_');
 }
 exports.getEnumPropertyName = getEnumPropertyName;
 function getObjectNameByRef(ref) {
@@ -149,10 +164,7 @@ function joinCommentLines(indent = 2, ...description) {
             ];
         }
         else if (Array.isArray(entry)) {
-            descriptionLines = [
-                ...descriptionLines,
-                ...entry,
-            ];
+            descriptionLines = [...descriptionLines, ...entry];
         }
     });
     descriptionLines = utils_1.trimArray(descriptionLines);
@@ -181,7 +193,7 @@ function joinOneOfValues(values, primitive) {
 }
 exports.joinOneOfValues = joinOneOfValues;
 function formatArrayDepth(value, depth) {
-    if (value.endsWith('\'') || value.includes('|')) {
+    if (value.endsWith("'") || value.includes('|')) {
         return `Array<${value}>` + '[]'.repeat(depth - 1); // Need decrement depth value because of Array<T> has its own depth
     }
     else {

package/dist/index.js

@@ -24,8 +24,8 @@ const helpMessage = `
 
   ${chalk_1.default.greenBright('--methods')}       List of methods to generate responses and all needed objects.
                   Example:
-                  - ${chalk_1.default.bold('\'*\'')} - to generate all responses and objects.
-                  - ${chalk_1.default.bold('\'messages.*, users.get, groups.isMember\'')} - to generate all methods from messages section, users.get and groups.isMember.
+                  - ${chalk_1.default.bold("'*'")} - to generate all responses and objects.
+                  - ${chalk_1.default.bold("'messages.*, users.get, groups.isMember'")} - to generate all methods from messages section, users.get and groups.isMember.
 `;
 async function main() {
     console.log(chalk_1.default.bold('VK API Schema TypeScript generator'));
@@ -52,7 +52,7 @@ async function main() {
     schemaDir = path_1.default.resolve(schemaDir);
     outDir = outDir ? path_1.default.resolve(outDir) : '';
     // Read and check required schema files
-    const [methodsDefinitions, { definitions: responsesDefinitions }, { definitions: objectsDefinitions },] = await Promise.all([
+    const [methodsDefinitions, { definitions: responsesDefinitions }, { definitions: objectsDefinitions }, { errors: errorsDefinitions },] = await Promise.all([
         helpers_1.readJSONFile(path_1.default.resolve(schemaDir, 'methods.json')),
         helpers_1.readJSONFile(path_1.default.resolve(schemaDir, 'responses.json')),
         helpers_1.readJSONFile(path_1.default.resolve(schemaDir, 'objects.json')),
@@ -77,6 +77,7 @@ async function main() {
         methodsDefinitions,
         objects: objectsDefinitions,
         responses: responsesDefinitions,
+        errors: errorsDefinitions,
         methodsPattern: methods.join(','),
     });
     generator.generate();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/api-schema-typescript-generator",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "license": "MIT",
   "description": "VK API TypeScript generator",
   "author": {
@@ -33,14 +33,16 @@
     "clear": "rimraf dist/*",
     "build": "yarn clear && tsc",
     "watch": "yarn clear && tsc --watch",
-    "test": "jest && tsc --noEmit && eslint src --ext .ts"
+    "prettier": "prettier --write \"src/**/*.ts\"",
+    "test": "jest && tsc --noEmit && eslint src --ext .ts && yarn prettier"
   },
   "pre-commit": [
     "test"
   ],
   "dependencies": {
     "arg": "^4.1.3",
-    "chalk": "4.1.0"
+    "chalk": "4.1.0",
+    "prettier": "^2.7.1"
   },
   "devDependencies": {
     "@types/jest": "^28.1.5",

package/src/generator.ts

@@ -3,7 +3,11 @@ import { getInterfaceName, getSectionFromObjectName } from './helpers';
 import { Dictionary, ObjectType, RefsDictionary, RefsDictionaryType } from './types';
 import { sortArrayAlphabetically, uniqueArray } from './utils';
 
-export function generateImportsBlock(refs: RefsDictionary, section: string | null, type?: ObjectType): string {
+export function generateImportsBlock(
+  refs: RefsDictionary,
+  section: string | null,
+  type?: ObjectType,
+): string {
   let importRefs = Object.entries(refs)
     .filter(([, type]) => type === RefsDictionaryType.GenerateAndImport)
     .map(([key]) => key);

package/src/generators/APITypingsGenerator.ts

@@ -1,15 +1,16 @@
 import * as Schema from '../types/schema';
-import {
-  Dictionary,
-  ObjectType,
-  RefsDictionary,
-} from '../types';
+import { Dictionary, ObjectType, RefsDictionary } from '../types';
 import { generateEnumAsUnionType } from './enums';
 import { normalizeMethodInfo } from './methods';
 import { SchemaObject } from './SchemaObject';
 import {
-  getInterfaceName, getMethodSection, getObjectNameByRef,
-  getSectionFromObjectName, isMethodNeeded, isPatternProperty, prepareBuildDirectory,
+  getInterfaceName,
+  getMethodSection,
+  getObjectNameByRef,
+  getSectionFromObjectName,
+  isMethodNeeded,
+  isPatternProperty,
+  prepareBuildDirectory,
   prepareMethodsPattern,
   writeFile,
 } from '../helpers';
@@ -20,7 +21,8 @@ import {
   baseAPIParamsInterfaceName,
   baseBoolIntRef,
   baseOkResponseRef,
-  basePropertyExistsRef, DEFAULT_API_VERSION,
+  basePropertyExistsRef,
+  DEFAULT_API_VERSION,
   newLineChar,
 } from '../constants';
 import path from 'path';
@@ -28,6 +30,7 @@ import { CommentCodeBlock } from './CommentCodeBlock';
 import { consoleLogError, consoleLogErrorAndExit, consoleLogInfo } from '../log';
 import { generateImportsBlock } from '../generator';
 import { generateTypeString } from './typeString';
+import { ErrorInterface } from '../types/schema';
 
 interface APITypingsGeneratorOptions {
   needEmit: boolean;
@@ -47,6 +50,7 @@ interface APITypingsGeneratorOptions {
   methodsDefinitions: Schema.API;
   objects: Dictionary<SchemaObject>;
   responses: Dictionary<SchemaObject>;
+  errors: Dictionary<ErrorInterface>;
 }
 
 export class APITypingsGenerator {
@@ -59,6 +63,7 @@ export class APITypingsGenerator {
     this.methodsList = options.methodsDefinitions.methods || [];
     this.objects = this.convertJSONSchemaDictionary(options.objects);
     this.responses = this.convertJSONSchemaDictionary(options.responses);
+    this.errors = options.errors;
 
     this.visitedRefs = {};
     this.generatedObjects = {};
@@ -68,7 +73,7 @@ export class APITypingsGenerator {
 
     this.ignoredResponses = {
       'storage.get': {
-        'keysResponse': true,
+        keysResponse: true,
       },
     };
 
@@ -83,6 +88,7 @@ export class APITypingsGenerator {
   methodsList!: NonNullable<Schema.API['methods']>;
   objects!: Dictionary<SchemaObject>;
   responses!: Dictionary<SchemaObject>;
+  errors!: Dictionary<ErrorInterface>;
 
   visitedRefs!: Dictionary<boolean>;
   generatedObjects!: Dictionary<boolean>;
@@ -129,10 +135,7 @@ export class APITypingsGenerator {
         ...methodFile.imports,
         ...imports,
       },
-      codeBlocks: [
-        ...methodFile.codeBlocks,
-        ...codeBlocks,
-      ],
+      codeBlocks: [...methodFile.codeBlocks, ...codeBlocks],
     };
   }
 
@@ -192,10 +195,7 @@ export class APITypingsGenerator {
         }
 
         if (additionalProperties.length) {
-          properties = [
-            ...properties,
-            ...additionalProperties,
-          ];
+          properties = [...properties, ...additionalProperties];
         }
       });
     }
@@ -265,10 +265,7 @@ export class APITypingsGenerator {
     });
 
     return {
-      codeBlocks: [
-        ...codeBlocks,
-        codeBlock,
-      ],
+      codeBlocks: [...codeBlocks, codeBlock],
       imports,
       value: '',
     };
@@ -338,12 +335,18 @@ export class APITypingsGenerator {
 
     if (stringCodeBlocks.length > 0) {
       const code = stringCodeBlocks.join(newLineChar.repeat(2));
-      this.registerResultFile(path.join('objects', section, `${getInterfaceName(object.name)}.ts`), code);
+      this.registerResultFile(
+        path.join('objects', section, `${getInterfaceName(object.name)}.ts`),
+        code,
+      );
     }
 
     codeBlocks.forEach((codeBlock) => {
       if (codeBlock instanceof TypeCodeBlock && codeBlock.needExport && codeBlock.interfaceName) {
-        this.registerExport(`./objects/${section}/${getInterfaceName(object.name)}.ts`, codeBlock.interfaceName);
+        this.registerExport(
+          `./objects/${section}/${getInterfaceName(object.name)}.ts`,
+          codeBlock.interfaceName,
+        );
       }
     });
 
@@ -399,7 +402,9 @@ export class APITypingsGenerator {
         imports: newImports,
         value,
         codeBlocks: newCodeBlocks,
-      } = generateTypeString(property, this.objects, { needEnumNamesConstant: false });
+      } = generateTypeString(property, this.objects, {
+        needEnumNamesConstant: false,
+      });
 
       imports = { ...imports, ...newImports };
       codeBlocks = [...codeBlocks, ...newCodeBlocks];
@@ -432,11 +437,13 @@ export class APITypingsGenerator {
 
     if (object.enum) {
       const { codeBlocks: newCodeBlocks } = generateEnumAsUnionType(object);
-      codeBlocks = [
-        ...newCodeBlocks,
-      ];
+      codeBlocks = [...newCodeBlocks];
     } else {
-      const { imports: newImports, value, codeBlocks: newCodeBlocks } = generateTypeString(object, this.objects);
+      const {
+        imports: newImports,
+        value,
+        codeBlocks: newCodeBlocks,
+      } = generateTypeString(object, this.objects);
       const codeBlock = new TypeCodeBlock({
         type: TypeScriptCodeTypes.Type,
         refName: object.name,
@@ -448,11 +455,7 @@ export class APITypingsGenerator {
       });
 
       imports = newImports;
-      codeBlocks = [
-        ...codeBlocks,
-        ...newCodeBlocks,
-        codeBlock,
-      ];
+      codeBlocks = [...codeBlocks, ...newCodeBlocks, codeBlock];
     }
 
     return {
@@ -462,13 +465,11 @@ export class APITypingsGenerator {
     };
   }
 
-  private getResponseCodeBlockAsType(object: SchemaObject, response: SchemaObject): GeneratorResultInterface | false {
-    const {
-      imports,
-      value,
-      codeBlocks,
-      description,
-    } = generateTypeString(response, this.objects, {
+  private getResponseCodeBlockAsType(
+    object: SchemaObject,
+    response: SchemaObject,
+  ): GeneratorResultInterface | false {
+    const { imports, value, codeBlocks, description } = generateTypeString(response, this.objects, {
       objectParentName: ' ', // TODO: Refactor
     });
 
@@ -476,20 +477,14 @@ export class APITypingsGenerator {
       type: TypeScriptCodeTypes.Type,
       refName: object.name,
       interfaceName: getInterfaceName(object.name),
-      description: [
-        object.description,
-        description || '',
-      ].join(newLineChar),
+      description: [object.description, description || ''].join(newLineChar),
       needExport: true,
       properties: [],
       value,
     });
 
     return {
-      codeBlocks: [
-        ...codeBlocks,
-        codeBlock,
-      ],
+      codeBlocks: [...codeBlocks, codeBlock],
       imports,
       value: '',
       description,
@@ -576,17 +571,11 @@ export class APITypingsGenerator {
     // Comment with method name for visual sections in file
     const methodNameComment = new CommentCodeBlock([methodName]);
     if (method.description) {
-      methodNameComment.appendLines([
-        '',
-        method.description,
-      ]);
+      methodNameComment.appendLines(['', method.description]);
     }
     this.appendToFileMap(section, {}, [methodNameComment]);
 
-    const {
-      method: normalizedMethod,
-      parameterRefs,
-    } = normalizeMethodInfo(method);
+    const { method: normalizedMethod, parameterRefs } = normalizeMethodInfo(method);
 
     method = normalizedMethod;
     this.generateObjectsFromRefs(parameterRefs);
@@ -619,15 +608,48 @@ export class APITypingsGenerator {
           this.registerExport(`./methods/${section}`, codeBlock.interfaceName);
         }
       });
-      const code = [
-        generateImportsBlock(imports, null),
-        ...codeBlocks,
-      ];
+      const code = [generateImportsBlock(imports, null), ...codeBlocks];
 
-      this.registerResultFile(path.join('methods', `${section}.ts`), code.join(newLineChar.repeat(2)));
+      this.registerResultFile(
+        path.join('methods', `${section}.ts`),
+        code.join(newLineChar.repeat(2)),
+      );
     });
   }
 
+  private generateErrors() {
+    consoleLogInfo('creating errors...');
+
+    const code: string[] = [];
+
+    Object.entries(this.errors)
+      .reduce<Array<ErrorInterface & { name: string }>>((acc, [name, error]) => {
+        acc.push({ name, ...error });
+        return acc;
+      }, [])
+      .sort((errorA, errorB) => {
+        return errorA.code - errorB.code;
+      })
+      .forEach((error) => {
+        const errorConstantName = error.name.toUpperCase();
+
+        code.push(
+          new TypeCodeBlock({
+            type: TypeScriptCodeTypes.Const,
+            interfaceName: errorConstantName,
+            needExport: true,
+            value: String(error.code),
+            properties: [],
+            description: [error.description, error.$comment || ''].join(newLineChar.repeat(2)),
+          }).toString(),
+        );
+
+        this.registerExport('./common/errors', errorConstantName);
+      });
+
+    this.registerResultFile(path.join('common', 'errors.ts'), code.join(newLineChar.repeat(2)));
+  }
+
   private createCommonTypes() {
     consoleLogInfo('creating common types...');
     const code: string[] = [];
@@ -708,6 +730,7 @@ export class APITypingsGenerator {
     consoleLogInfo('generate');
 
     this.generateMethods();
+    this.generateErrors();
 
     if (this.needEmit) {
       this.createCommonTypes();

package/src/generators/CommentCodeBlock.ts

@@ -10,19 +10,12 @@ export class CommentCodeBlock extends BaseCodeBlock {
   lines: string[];
 
   appendLines(lines: string[]) {
-    this.lines = [
-      ...this.lines,
-      ...lines,
-    ];
+    this.lines = [...this.lines, ...lines];
   }
 
   toString(): string {
     const inner = this.lines.map((line) => spaceChar + `* ${line}`.trim());
 
-    return [
-      '/**',
-      ...inner,
-      ' */',
-    ].join(newLineChar);
+    return ['/**', ...inner, ' */'].join(newLineChar);
   }
 }

package/src/generators/SchemaObject.ts

@@ -1,14 +1,16 @@
 import { EnumLikeArray } from '../types';
 import { isObject, isString } from '../utils';
-import {
-  transformPatternPropertyName,
-} from '../helpers';
+import { transformPatternPropertyName } from '../helpers';
 import { consoleLogErrorAndExit } from '../log';
 
 export class SchemaObject {
   constructor(name: string, object: any, parentName?: string) {
     if (!isObject(object)) {
-      consoleLogErrorAndExit(`[SchemaObject] "${name}" is not an object.`, { name, object, parentName });
+      consoleLogErrorAndExit(`[SchemaObject] "${name}" is not an object.`, {
+        name,
+        object,
+        parentName,
+      });
       return;
     }
 
@@ -67,9 +69,13 @@ export class SchemaObject {
     }
 
     if (object.patternProperties) {
-      Object.entries(object.patternProperties).forEach(([propertyName, property]: [string, any]) => {
-        this.properties.push(new SchemaObject(transformPatternPropertyName(propertyName), property, name));
-      });
+      Object.entries(object.patternProperties).forEach(
+        ([propertyName, property]: [string, any]) => {
+          this.properties.push(
+            new SchemaObject(transformPatternPropertyName(propertyName), property, name),
+          );
+        },
+      );
     }
 
     if (isObject(object.items)) {
@@ -112,6 +118,9 @@ export class SchemaObject {
   }
 
   public clone() {
-    return Object.assign(Object.create(Object.getPrototypeOf(this)), this) as NonNullable<SchemaObject>;
+    return Object.assign(
+      Object.create(Object.getPrototypeOf(this)),
+      this,
+    ) as NonNullable<SchemaObject>;
   }
 }

package/src/generators/TypeCodeBlock.ts

@@ -9,6 +9,7 @@ export enum TypeScriptCodeTypes {
   Enum = 'enum',
   ConstantObject = 'constant_object',
   Type = 'type',
+  Const = 'const',
 }
 
 export interface TypeCodeBlockProperty {
@@ -63,41 +64,45 @@ export class TypeCodeBlock extends BaseCodeBlock {
   }
 
   private getPropertiesCode() {
-    const quoteChar = this.properties.some((property) => areQuotesNeededForProperty(property.name)) ? '\'' : '';
-
-    return this.properties.map((property) => {
-      let divider = '';
-      let lineEnd = '';
-
-      switch (this.type) {
-        case TypeScriptCodeTypes.Interface:
-          divider = property.isRequired ? ':' : '?:';
-          lineEnd = ';';
-          break;
-        case TypeScriptCodeTypes.ConstantObject:
-          divider = ':';
-          lineEnd = ',';
-          break;
-        case TypeScriptCodeTypes.Enum:
-          divider = ' =';
-          lineEnd = ',';
-          break;
-      }
+    const quoteChar = this.properties.some((property) => areQuotesNeededForProperty(property.name))
+      ? "'"
+      : '';
+
+    return this.properties
+      .map((property) => {
+        let divider = '';
+        let lineEnd = '';
+
+        switch (this.type) {
+          case TypeScriptCodeTypes.Interface:
+            divider = property.isRequired ? ':' : '?:';
+            lineEnd = ';';
+            break;
+          case TypeScriptCodeTypes.ConstantObject:
+            divider = ':';
+            lineEnd = ',';
+            break;
+          case TypeScriptCodeTypes.Enum:
+            divider = ' =';
+            lineEnd = ',';
+            break;
+        }
 
-      let value = property.wrapValue ? quoteJavaScriptValue(property.value) : property.value;
-      let propertyCode = [
-        `  ${quoteChar}${property.name}${quoteChar}${divider} ${value}${lineEnd}`,
-      ];
+        let value = property.wrapValue ? quoteJavaScriptValue(property.value) : property.value;
+        let propertyCode = [
+          `  ${quoteChar}${property.name}${quoteChar}${divider} ${value}${lineEnd}`,
+        ];
 
-      if (property.description) {
-        const commentLines = joinCommentLines(2, property.description);
-        if (commentLines.length) {
-          propertyCode.unshift(commentLines.join(newLineChar));
+        if (property.description) {
+          const commentLines = joinCommentLines(2, property.description);
+          if (commentLines.length) {
+            propertyCode.unshift(commentLines.join(newLineChar));
+          }
         }
-      }
 
-      return propertyCode.join(newLineChar);
-    }).join(newLineChar);
+        return propertyCode.join(newLineChar);
+      })
+      .join(newLineChar);
   }
 
   toString(): string {
@@ -113,10 +118,7 @@ export class TypeCodeBlock extends BaseCodeBlock {
     }
 
     if (this.description) {
-      before = [
-        ...before,
-        ...joinCommentLines(0, this.description),
-      ];
+      before = [...before, ...joinCommentLines(0, this.description)];
     }
 
     switch (this.type) {
@@ -125,19 +127,19 @@ export class TypeCodeBlock extends BaseCodeBlock {
           if (this.options.allowEmptyInterface) {
             propertiesCode = '';
           } else {
-            propertiesCode = [
-              '  // empty interface',
-              '  [key: string]: any;',
-            ].join(newLineChar);
+            propertiesCode = ['  // empty interface', '  [key: string]: any;'].join(newLineChar);
           }
         }
 
-        const extendsInterfaces = Array.isArray(this.extendsInterfaces) && this.extendsInterfaces.length ?
-          this.extendsInterfaces.join(', ') :
-          '';
+        const extendsInterfaces =
+          Array.isArray(this.extendsInterfaces) && this.extendsInterfaces.length
+            ? this.extendsInterfaces.join(', ')
+            : '';
 
         code = [
-          trimStringDoubleSpaces(`${exportKeyword} interface ${this.interfaceName} ${extendsInterfaces} {`),
+          trimStringDoubleSpaces(
+            `${exportKeyword} interface ${this.interfaceName} ${extendsInterfaces} {`,
+          ),
           propertiesCode,
           '}',
         ].join(propertiesCode.length ? newLineChar : '');
@@ -169,11 +171,18 @@ export class TypeCodeBlock extends BaseCodeBlock {
           trimStringDoubleSpaces(`${exportKeyword} type ${this.interfaceName} = ${this.value};`),
         ].join(newLineChar);
         break;
+
+      case TypeScriptCodeTypes.Const:
+        if (!this.value) {
+          consoleLogErrorAndExit(`"${this.interfaceName}" type has empty value`);
+        }
+
+        code = [
+          trimStringDoubleSpaces(`${exportKeyword} const ${this.interfaceName} = ${this.value};`),
+        ].join(newLineChar);
+        break;
     }
 
-    return [
-      before.join(newLineChar),
-      code,
-    ].join(newLineChar).trim();
+    return [before.join(newLineChar), code].join(newLineChar).trim();
   }
 }

package/src/generators/enums.ts

@@ -18,7 +18,11 @@ export function getEnumNamesIdentifier(name: string) {
   return `${name} enumNames`.trim();
 }
 
-export function generateEnumConstantObject(object: SchemaObject, objectName: string, enumNames: Array<string | number>) {
+export function generateEnumConstantObject(
+  object: SchemaObject,
+  objectName: string,
+  enumNames: Array<string | number>,
+) {
   const enumInterfaceName = getInterfaceName(objectName);
 
   const codeBlock = new TypeCodeBlock({
@@ -52,10 +56,7 @@ export function generateEnumAsUnionType(object: SchemaObject): GeneratorResultIn
     type: TypeScriptCodeTypes.Type,
     refName: object.name,
     interfaceName: getInterfaceName(object.name),
-    description: [
-      object.description,
-      description,
-    ].join(newLineChar),
+    description: [object.description, description].join(newLineChar),
     needExport: true,
     properties: [],
     value,
@@ -97,12 +98,11 @@ interface GenerateInlineEnumOptions {
   refName?: string;
 }
 
-export function generateInlineEnum(object: SchemaObject, options: GenerateInlineEnumOptions = {}): GeneratorResultInterface {
-  const {
-    isNumericEnum,
-    enumNames,
-    needEnumNamesDescription,
-  } = getEnumNames(object);
+export function generateInlineEnum(
+  object: SchemaObject,
+  options: GenerateInlineEnumOptions = {},
+): GeneratorResultInterface {
+  const { isNumericEnum, enumNames, needEnumNamesDescription } = getEnumNames(object);
 
   options = {
     needEnumNamesConstant: isNumericEnum,

package/src/generators/methods.ts

@@ -37,9 +37,9 @@ export function normalizeMethodInfo(method: Schema.Method): NormalizeMethodInfoR
       const ref = parameter.items?.$ref;
       parameterRefs[ref] = RefsDictionaryType.Generate;
 
-      parameter.description += newLineChar.repeat(2) + [
-        `@see ${getInterfaceName(getObjectNameByRef(ref))} (${ref})`,
-      ].join(newLineChar);
+      parameter.description +=
+        newLineChar.repeat(2) +
+        [`@see ${getInterfaceName(getObjectNameByRef(ref))} (${ref})`].join(newLineChar);
     }
   });
 

package/src/generators/typeString.ts

@@ -28,7 +28,10 @@ interface GenerateTypeStringOptions {
   needEnumNamesConstant?: boolean;
 }
 
-function generateBaseType(object: SchemaObject, options: GenerateTypeStringOptions): GeneratorResultInterface {
+function generateBaseType(
+  object: SchemaObject,
+  options: GenerateTypeStringOptions,
+): GeneratorResultInterface {
   let codeBlocks: CodeBlocksArray = [];
   let typeString = 'any /* default type */';
   let imports: RefsDictionary = {};

package/src/helpers.ts

@@ -4,6 +4,7 @@ import { capitalizeFirstLetter, trimArray } from './utils';
 import { newLineChar, primitiveTypes, spaceChar } from './constants';
 import { Dictionary } from './types';
 import { consoleLogErrorAndExit } from './log';
+import prettier from 'prettier';
 
 export async function readJSONFile(path: string): Promise<any> {
   const content = await fsPromises.readFile(path, 'utf-8');
@@ -31,16 +32,29 @@ export function prepareBuildDirectory(directoryPath: string) {
 
 export function writeFile(filePath: string, code: string, insertAutoGeneratedNote = true) {
   if (insertAutoGeneratedNote) {
-    code = [
-      '/**',
-      ' * This is auto-generated file, don\'t modify this file manually',
-      ' */',
-      // '/* eslint-disable max-len */',
-      // '/* eslint-disable @typescript-eslint/no-empty-interface */',
-    ].join(newLineChar) + newLineChar.repeat(2) + code.trim();
+    code =
+      [
+        '/**',
+        " * This is auto-generated file, don't modify this file manually",
+        ' */',
+        // '/* eslint-disable max-len */',
+        // '/* eslint-disable @typescript-eslint/no-empty-interface */',
+      ].join(newLineChar) +
+      newLineChar.repeat(2) +
+      code.trim();
   }
 
-  fs.mkdirSync(filePath.replace(path.basename(filePath), ''), { recursive: true });
+  code = prettier.format(code, {
+    semi: true,
+    singleQuote: true,
+    trailingComma: 'all',
+    quoteProps: 'consistent',
+    parser: 'typescript',
+  });
+
+  fs.mkdirSync(filePath.replace(path.basename(filePath), ''), {
+    recursive: true,
+  });
   fs.writeFileSync(filePath, code.trim() + newLineChar);
 }
 
@@ -49,10 +63,13 @@ export function prepareMethodsPattern(methodsPattern: string): Dictionary<boolea
     consoleLogErrorAndExit('methodsPattern is empty. Pass "*" to generate all methods');
   }
 
-  return methodsPattern.replace(/\s+/g, '').split(',').reduce<Dictionary<boolean>>((acc, pattern) => {
-    acc[pattern] = true;
-    return acc;
-  }, {});
+  return methodsPattern
+    .replace(/\s+/g, '')
+    .split(',')
+    .reduce<Dictionary<boolean>>((acc, pattern) => {
+      acc[pattern] = true;
+      return acc;
+    }, {});
 }
 
 export function isMethodNeeded(methodsPattern: Dictionary<boolean>, method: string): boolean {
@@ -77,18 +94,17 @@ export function getMethodSection(methodName: string): string {
 }
 
 export function getInterfaceName(name: string): string {
-  name = name.replace(/\.|(\s+)|_/g, ' ')
+  name = name
+    .replace(/\.|(\s+)|_/g, ' ')
     .split(' ')
-    .map((v) => capitalizeFirstLetter(v)).join('');
+    .map((v) => capitalizeFirstLetter(v))
+    .join('');
 
   return capitalizeFirstLetter(name);
 }
 
 export function getEnumPropertyName(name: string): string {
-  return name.toUpperCase()
-    .replace(/\s+/g, '_')
-    .replace(/-/g, '_')
-    .replace(/\./g, '_');
+  return name.toUpperCase().replace(/\s+/g, '_').replace(/-/g, '_').replace(/\./g, '_');
 }
 
 export function getObjectNameByRef(ref: string): string {
@@ -136,10 +152,7 @@ export function joinCommentLines(indent = 2, ...description: Array<string | stri
         ...trimArray((entry || '').trim().split(newLineChar)),
       ];
     } else if (Array.isArray(entry)) {
-      descriptionLines = [
-        ...descriptionLines,
-        ...entry,
-      ];
+      descriptionLines = [...descriptionLines, ...entry];
     }
   });
 
@@ -171,7 +184,7 @@ export function joinOneOfValues(values: Array<string | number>, primitive?: bool
 }
 
 export function formatArrayDepth(value: string, depth: number) {
-  if (value.endsWith('\'') || value.includes('|')) {
+  if (value.endsWith("'") || value.includes('|')) {
     return `Array<${value}>` + '[]'.repeat(depth - 1); // Need decrement depth value because of Array<T> has its own depth
   } else {
     return value + '[]'.repeat(depth);

package/src/index.ts

@@ -11,16 +11,24 @@ const helpMessage = `
 
   ${chalk.greenBright('--help')}          Shows this help.
 
-  ${chalk.greenBright('--schemaDir')}     The relative path to directory with ${chalk.bold('methods.json')}, ${chalk.bold('objects.json')} and ${chalk.bold('responses.json')} files.
+  ${chalk.greenBright('--schemaDir')}     The relative path to directory with ${chalk.bold(
+  'methods.json',
+)}, ${chalk.bold('objects.json')} and ${chalk.bold('responses.json')} files.
 
   ${chalk.greenBright('--outDir')}        The directory where the files will be generated.
                   If you skip this param, script will work in linter mode without emitting files to file system.
-                  ${chalk.bold('Please note')} that this folder will be cleared after starting the generation.
+                  ${chalk.bold(
+                    'Please note',
+                  )} that this folder will be cleared after starting the generation.
 
-  ${chalk.greenBright('--methods')}       List of methods to generate responses and all needed objects.
+  ${chalk.greenBright(
+    '--methods',
+  )}       List of methods to generate responses and all needed objects.
                   Example:
-                  - ${chalk.bold('\'*\'')} - to generate all responses and objects.
-                  - ${chalk.bold('\'messages.*, users.get, groups.isMember\'')} - to generate all methods from messages section, users.get and groups.isMember.
+                  - ${chalk.bold("'*'")} - to generate all responses and objects.
+                  - ${chalk.bold(
+                    "'messages.*, users.get, groups.isMember'",
+                  )} - to generate all methods from messages section, users.get and groups.isMember.
 `;
 
 export async function main() {
@@ -61,6 +69,7 @@ export async function main() {
     methodsDefinitions,
     { definitions: responsesDefinitions },
     { definitions: objectsDefinitions },
+    { errors: errorsDefinitions },
   ] = await Promise.all([
     readJSONFile(path.resolve(schemaDir, 'methods.json')),
     readJSONFile(path.resolve(schemaDir, 'responses.json')),
@@ -91,6 +100,7 @@ export async function main() {
     methodsDefinitions,
     objects: objectsDefinitions,
     responses: responsesDefinitions,
+    errors: errorsDefinitions,
     methodsPattern: methods.join(','),
   });
 

package/src/types/schema.ts

@@ -150,3 +150,10 @@ export interface Response {
   };
   additionalProperties?: boolean;
 }
+
+export interface ErrorInterface {
+  code: number;
+  description: string;
+  $comment?: string;
+  subcodes?: Array<{ $ref: string }>;
+}