@vkontakte/api-schema-typescript-generator 0.16.0 → 0.17.1

package/.github/CODEOWNERS

@@ -1 +1 @@
-.github/dependabot.yml  @VKCOM/vk-sec
+.github/ @VKCOM/vk-sec

package/.github/workflows/publish.yml

@@ -10,14 +10,17 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read # Recommended for actions/setup-node
+      id-token: write # Required for OIDC
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           token: ${{ secrets.DEVTOOLS_GITHUB_TOKEN }}
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version-file: '.nvmrc'
           cache: 'yarn'
           always-auth: true
           registry-url: 'https://registry.npmjs.org'
@@ -43,5 +46,3 @@ jobs:
 
       - name: Publushing release
         run: yarn publish --non-interactive
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPMJS_PUBLISH_TOKEN }}

package/.github/workflows/pull_request.yml

@@ -6,9 +6,9 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 18
           cache: 'yarn'

package/.nvmrc

@@ -0,0 +1 @@
+v24.11.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 V Kontakte, LLC.
+Copyright (c) 2020 VK LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cli.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArguments = void 0;
+exports.parseArguments = parseArguments;
 const arg_1 = __importDefault(require("arg"));
 const utils_1 = require("./utils");
 function parseArguments() {
@@ -26,4 +26,3 @@ function parseArguments() {
         methods: (0, utils_1.trimArray)(args['--methods'] || []),
     };
 }
-exports.parseArguments = parseArguments;

package/dist/generator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportsBlock = void 0;
+exports.generateImportsBlock = generateImportsBlock;
 const constants_1 = require("./constants");
 const helpers_1 = require("./helpers");
 const types_1 = require("./types");
@@ -38,4 +38,3 @@ function generateImportsBlock(refs, section, type) {
     });
     return importLines.join(constants_1.newLineChar);
 }
-exports.generateImportsBlock = generateImportsBlock;

package/dist/generators/APITypingsGenerator.js

@@ -280,12 +280,12 @@ class APITypingsGenerator {
     }
     generateMethodParams(methodInfo) {
         const section = (0, helpers_1.getMethodSection)(methodInfo.name);
-        const interfaceName = `${methodInfo.name} params`;
+        const interfaceName = (0, helpers_1.getInterfaceName)(`${methodInfo.name} params`);
         let imports = {};
         let codeBlocks = [];
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
-            interfaceName: (0, helpers_1.getInterfaceName)(interfaceName),
+            interfaceName: interfaceName,
             needExport: true,
             allowEmptyInterface: true,
             properties: [],
@@ -305,6 +305,7 @@ class APITypingsGenerator {
         });
         this.appendToFileMap(section, imports, [...codeBlocks, codeBlock]);
         this.generateObjectsFromImports(imports);
+        return interfaceName;
     }
     getResponseObjectRef(ref) {
         const objectName = (0, helpers_1.getObjectNameByRef)(ref);
@@ -404,7 +405,7 @@ class APITypingsGenerator {
     generateResponse(section, response) {
         const result = this.getResponseCodeBlock(response);
         if (!result) {
-            return;
+            throw new Error('Unable to generate response');
         }
         const { codeBlocks, imports } = result;
         this.appendToFileMap(section, imports, codeBlocks);
@@ -430,14 +431,53 @@ class APITypingsGenerator {
         const { method: normalizedMethod, parameterRefs } = (0, 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]) => {
+        const methodParamsInterfaceName = this.generateMethodParams(new SchemaObject_1.SchemaObject(method.name, method));
+        const methodResponsesInterfaceName = Object.entries(method.responses)
+            .map(([responseName, responseObject]) => {
             if (this.ignoredResponses[methodName] && this.ignoredResponses[methodName][responseName]) {
                 return;
             }
             const name = `${methodName}_${responseName}`;
-            this.generateResponse(section, new SchemaObject_1.SchemaObject(name, responseObject));
+            const interfaceName = (0, helpers_1.getInterfaceName)(name);
+            try {
+                this.generateResponse(section, new SchemaObject_1.SchemaObject(name, responseObject));
+                return interfaceName;
+            }
+            catch (e) {
+                return;
+            }
+        })
+            .filter(Boolean);
+        this.generateMethodType(methodName, methodParamsInterfaceName, methodResponsesInterfaceName);
+    }
+    generateMethodType(methodName, methodParamsInterfaceName, methodResponsesInterfaceName) {
+        const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
+            interfaceName: (0, helpers_1.getInterfaceName)(`${methodName} method`),
+            needExport: true,
+            allowEmptyInterface: true,
+            properties: [],
+        });
+        codeBlock.addProperty({
+            name: 'method',
+            value: methodName,
+            isRequired: true,
+            wrapValue: true,
+        });
+        codeBlock.addProperty({
+            name: 'request',
+            value: methodParamsInterfaceName,
+            isRequired: true,
         });
+        codeBlock.addProperty({
+            name: 'response',
+            value: methodResponsesInterfaceName.length > 0
+                ? methodResponsesInterfaceName.join(' | ')
+                : 'unknown',
+            isRequired: true,
+        });
+        const section = (0, helpers_1.getMethodSection)(methodName);
+        this.appendToFileMap(section, {}, [codeBlock]);
     }
     generateMethods() {
         (0, log_1.consoleLogInfo)('creating method params and responses...');
@@ -448,11 +488,33 @@ class APITypingsGenerator {
         });
         Object.keys(this.methodFilesMap).forEach((section) => {
             const { imports, codeBlocks } = this.methodFilesMap[section];
+            const methodNames = [];
             codeBlocks.forEach((codeBlock) => {
                 if (codeBlock instanceof TypeCodeBlock_1.TypeCodeBlock && codeBlock.needExport && codeBlock.interfaceName) {
+                    /**
+                     * for interfaceName structure
+                     * @see this.generateMethodType
+                     */
+                    if (codeBlock.interfaceName.endsWith('Method')) {
+                        methodNames.push(codeBlock.interfaceName);
+                        // Skip export as it will be exported in union type
+                        return;
+                    }
                     this.registerExport(`./methods/${section}`, codeBlock.interfaceName);
                 }
             });
+            if (methodNames.length > 0) {
+                const sectionMethodsCodeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+                    type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+                    interfaceName: (0, helpers_1.getInterfaceName)(`${section} methods union`),
+                    needExport: true,
+                    allowEmptyInterface: true,
+                    value: methodNames.join(' | '),
+                    properties: [],
+                });
+                codeBlocks.push(sectionMethodsCodeBlock);
+                this.registerExport(`./methods/${section}`, sectionMethodsCodeBlock.interfaceName);
+            }
             const code = [(0, generator_1.generateImportsBlock)(imports, null), ...codeBlocks];
             this.registerResultFile(path_1.default.join('methods', `${section}.ts`), code.join(constants_1.newLineChar.repeat(2)));
         });
@@ -513,8 +575,22 @@ class APITypingsGenerator {
                 },
             ],
         }).toString());
+        code.push(`
+type MethodOf<M> = M extends { method: string } ? M['method'] : never;
+type RequestOf<M> = M extends { request: unknown } ? M['request'] : never;
+type ResponseOf<M> = M extends { response: unknown } ? M['response'] : never;
+
+export type CreateMethodMap<Type extends { method: string }> = {
+  [Property in Type as Property['method']]: {
+    method: MethodOf<Property>;
+    request: RequestOf<Property>;
+    response: ResponseOf<Property>;
+  };
+};
+    `);
         this.registerExport('./common/common', 'API_VERSION');
         this.registerExport('./common/common', (0, helpers_1.getInterfaceName)(constants_1.baseAPIParamsInterfaceName));
+        this.registerExport('./common/common', 'CreateMethodMap');
         this.registerResultFile(path_1.default.join('common', 'common.ts'), code.join(constants_1.newLineChar.repeat(2)));
     }
     /**
@@ -524,6 +600,49 @@ class APITypingsGenerator {
         (0, log_1.consoleLogInfo)('creating index.ts exports...');
         const blocks = [];
         let exportedObjects = {};
+        let methodNames = new Set();
+        (0, utils_1.sortArrayAlphabetically)(Object.keys(this.exports)).forEach((path) => {
+            if (!path.startsWith('./methods/')) {
+                return;
+            }
+            const objects = Object.keys(this.exports[path]);
+            if (!objects.length) {
+                return;
+            }
+            const blockLines = [];
+            (0, utils_1.sortArrayAlphabetically)(objects).forEach((object) => {
+                /**
+                 * for interfaceName structure
+                 * @see this.generateMethods
+                 */
+                if (!methodNames.has(object) && /^[A-Z][a-zA-Z0-9]*MethodsUnion$/.test(object)) {
+                    methodNames.add(object);
+                    exportedObjects[object] = true; // To skip in export block
+                    blockLines.push(`  ${object},`);
+                }
+            });
+            if (blockLines.length > 0) {
+                blockLines.unshift('import type {');
+                blockLines.push(`} from '${path.replace('.ts', '')}';`);
+                blocks.push(blockLines.join(constants_1.newLineChar));
+            }
+        });
+        blocks.push("import type { CreateMethodMap } from './common/common';");
+        const methodsCodeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+            interfaceName: 'ApiMethodsUnion',
+            needExport: false,
+            properties: [],
+            value: Array.from(methodNames).join(' | '),
+        });
+        blocks.push(methodsCodeBlock.toString());
+        blocks.push(new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+            interfaceName: 'ApiMethodsMap',
+            needExport: true,
+            properties: [],
+            value: `CreateMethodMap<${methodsCodeBlock.interfaceName}>`,
+        }).toString());
         (0, utils_1.sortArrayAlphabetically)(Object.keys(this.exports)).forEach((path) => {
             const objects = Object.keys(this.exports[path]);
             if (!objects.length) {

package/dist/generators/enums.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateInlineEnum = exports.generateEnumAsUnionType = exports.generateEnumConstantObject = exports.getEnumNamesIdentifier = exports.isNumericEnum = void 0;
+exports.isNumericEnum = isNumericEnum;
+exports.getEnumNamesIdentifier = getEnumNamesIdentifier;
+exports.generateEnumConstantObject = generateEnumConstantObject;
+exports.generateEnumAsUnionType = generateEnumAsUnionType;
+exports.generateInlineEnum = generateInlineEnum;
 const constants_1 = require("../constants");
 const helpers_1 = require("../helpers");
 const utils_1 = require("../utils");
@@ -8,14 +12,12 @@ const TypeCodeBlock_1 = require("./TypeCodeBlock");
 function isNumericEnum(object) {
     return object.enum.some((value) => !!+value);
 }
-exports.isNumericEnum = isNumericEnum;
 function getEnumNamesIdentifier(name) {
     if (!name) {
         throw new Error('[getEnumNamesIdentifier] empty name');
     }
     return `${name} enumNames`.trim();
 }
-exports.getEnumNamesIdentifier = getEnumNamesIdentifier;
 function generateEnumConstantObject(object, objectName, enumNames) {
     const enumInterfaceName = (0, helpers_1.getInterfaceName)(objectName);
     const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
@@ -34,7 +36,6 @@ function generateEnumConstantObject(object, objectName, enumNames) {
     });
     return codeBlock;
 }
-exports.generateEnumConstantObject = generateEnumConstantObject;
 /**
  * Generates enum as union type with constant object if necessary
  */
@@ -58,7 +59,6 @@ function generateEnumAsUnionType(object) {
         value: '',
     };
 }
-exports.generateEnumAsUnionType = generateEnumAsUnionType;
 function getEnumNames(object) {
     let { enumNames } = object;
     const isNumeric = isNumericEnum(object);
@@ -112,4 +112,3 @@ function generateInlineEnum(object, options = {}) {
         description: descriptionLines.join(constants_1.newLineChar),
     };
 }
-exports.generateInlineEnum = generateInlineEnum;

package/dist/generators/methods.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeMethodInfo = void 0;
+exports.normalizeMethodInfo = normalizeMethodInfo;
 const constants_1 = require("../constants");
 const helpers_1 = require("../helpers");
 const types_1 = require("../types");
@@ -38,4 +38,3 @@ function normalizeMethodInfo(method) {
         parameterRefs,
     };
 }
-exports.normalizeMethodInfo = normalizeMethodInfo;

package/dist/generators/typeString.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypeString = void 0;
+exports.generateTypeString = generateTypeString;
 const constants_1 = require("../constants");
 const enums_1 = require("./enums");
 const helpers_1 = require("../helpers");
@@ -146,4 +146,3 @@ function generateTypeString(object, objects, options = {}) {
         description,
     };
 }
-exports.generateTypeString = generateTypeString;

package/dist/generators/utils/mergeImports.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeImports = void 0;
+exports.mergeImports = mergeImports;
 const types_1 = require("../../types");
 function mergeImports(oldImports, newImports) {
     const result = { ...oldImports };
@@ -13,4 +13,3 @@ function mergeImports(oldImports, newImports) {
     });
     return result;
 }
-exports.mergeImports = mergeImports;

package/dist/helpers.js

@@ -15,18 +15,44 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePrimitiveTypesArray = exports.formatArrayDepth = exports.joinOneOfValues = exports.joinCommentLines = exports.transformPatternPropertyName = exports.areQuotesNeededForProperty = exports.isPatternProperty = exports.getSectionFromObjectName = exports.getObjectNameByRef = exports.getEnumPropertyName = exports.getInterfaceName = exports.getMethodSection = exports.isMethodNeeded = exports.prepareMethodsPattern = exports.writeFile = exports.prepareBuildDirectory = exports.readJSONFile = void 0;
+exports.readJSONFile = readJSONFile;
+exports.prepareBuildDirectory = prepareBuildDirectory;
+exports.writeFile = writeFile;
+exports.prepareMethodsPattern = prepareMethodsPattern;
+exports.isMethodNeeded = isMethodNeeded;
+exports.getMethodSection = getMethodSection;
+exports.getInterfaceName = getInterfaceName;
+exports.getEnumPropertyName = getEnumPropertyName;
+exports.getObjectNameByRef = getObjectNameByRef;
+exports.getSectionFromObjectName = getSectionFromObjectName;
+exports.isPatternProperty = isPatternProperty;
+exports.areQuotesNeededForProperty = areQuotesNeededForProperty;
+exports.transformPatternPropertyName = transformPatternPropertyName;
+exports.joinCommentLines = joinCommentLines;
+exports.joinOneOfValues = joinOneOfValues;
+exports.formatArrayDepth = formatArrayDepth;
+exports.resolvePrimitiveTypesArray = resolvePrimitiveTypesArray;
 const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
@@ -37,7 +63,6 @@ async function readJSONFile(path) {
     const content = await fs_1.promises.readFile(path, 'utf-8');
     return JSON.parse(content);
 }
-exports.readJSONFile = readJSONFile;
 function deleteDirectoryRecursive(directoryPath) {
     if (fs_1.default.existsSync(directoryPath)) {
         fs_1.default.readdirSync(directoryPath).forEach((file) => {
@@ -56,7 +81,6 @@ function prepareBuildDirectory(directoryPath) {
     deleteDirectoryRecursive(directoryPath);
     fs_1.default.mkdirSync(directoryPath, { recursive: true });
 }
-exports.prepareBuildDirectory = prepareBuildDirectory;
 function writeFile(filePath, code, insertAutoGeneratedNote = true) {
     if (insertAutoGeneratedNote) {
         code =
@@ -82,7 +106,6 @@ function writeFile(filePath, code, insertAutoGeneratedNote = true) {
     });
     fs_1.default.writeFileSync(filePath, code.trim() + constants_1.newLineChar);
 }
-exports.writeFile = writeFile;
 function prepareMethodsPattern(methodsPattern) {
     if (!methodsPattern) {
         (0, log_1.consoleLogErrorAndExit)('methodsPattern is empty. Pass "*" to generate all methods');
@@ -95,7 +118,6 @@ function prepareMethodsPattern(methodsPattern) {
         return acc;
     }, {});
 }
-exports.prepareMethodsPattern = prepareMethodsPattern;
 function isMethodNeeded(methodsPattern, method) {
     const [methodSection, methodName] = method.split('.');
     return Object.keys(methodsPattern).some((pattern) => {
@@ -109,11 +131,9 @@ function isMethodNeeded(methodsPattern, method) {
         return false;
     });
 }
-exports.isMethodNeeded = isMethodNeeded;
 function getMethodSection(methodName) {
     return methodName.split('.')[0];
 }
-exports.getMethodSection = getMethodSection;
 function getInterfaceName(name) {
     name = name
         .replace(/\.|(\s+)|_/g, ' ')
@@ -122,24 +142,19 @@ function getInterfaceName(name) {
         .join('');
     return (0, utils_1.capitalizeFirstLetter)(name);
 }
-exports.getInterfaceName = getInterfaceName;
 function getEnumPropertyName(name) {
     return name.toUpperCase().replace(/\s+/g, '_').replace(/-/g, '_').replace(/\./g, '_');
 }
-exports.getEnumPropertyName = getEnumPropertyName;
 function getObjectNameByRef(ref) {
     const parts = ref.split('/');
     return parts[parts.length - 1];
 }
-exports.getObjectNameByRef = getObjectNameByRef;
 function getSectionFromObjectName(name) {
     return name.split('_')[0];
 }
-exports.getSectionFromObjectName = getSectionFromObjectName;
 function isPatternProperty(name) {
     return name.startsWith('[key: ');
 }
-exports.isPatternProperty = isPatternProperty;
 function areQuotesNeededForProperty(name) {
     name = String(name);
     if (isPatternProperty(name)) {
@@ -150,14 +165,12 @@ function areQuotesNeededForProperty(name) {
     }
     return !(/^[a-z_]([a-z0-9_])+$/i.test(name) || /^[a-z_]/i.test(name));
 }
-exports.areQuotesNeededForProperty = areQuotesNeededForProperty;
 function transformPatternPropertyName(name) {
     if (name === '^[0-9]+$') {
         return '[key: number]';
     }
     return '[key: string] /* default pattern property name */';
 }
-exports.transformPatternPropertyName = transformPatternPropertyName;
 function joinCommentLines(indent = 2, ...description) {
     let descriptionLines = [];
     description.forEach((entry) => {
@@ -184,7 +197,6 @@ function joinCommentLines(indent = 2, ...description) {
         `${indentSpaces} */`,
     ];
 }
-exports.joinCommentLines = joinCommentLines;
 function joinOneOfValues(values, primitive) {
     const joined = values.join(' | ');
     if (joined.length > 120) {
@@ -195,7 +207,6 @@ function joinOneOfValues(values, primitive) {
         return joined;
     }
 }
-exports.joinOneOfValues = joinOneOfValues;
 function formatArrayDepth(value, depth) {
     if (value.endsWith("'") || value.includes('|')) {
         return `Array<${value}>` + '[]'.repeat(depth - 1); // Need decrement depth value because of Array<T> has its own depth
@@ -204,7 +215,6 @@ function formatArrayDepth(value, depth) {
         return value + '[]'.repeat(depth);
     }
 }
-exports.formatArrayDepth = formatArrayDepth;
 function resolvePrimitiveTypesArray(types) {
     const isEveryTypePrimitive = types.every((type) => !!constants_1.primitiveTypes[type]);
     if (isEveryTypePrimitive) {
@@ -212,4 +222,3 @@ function resolvePrimitiveTypesArray(types) {
     }
     return null;
 }
-exports.resolvePrimitiveTypesArray = resolvePrimitiveTypesArray;

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = void 0;
+exports.main = main;
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const perf_hooks_1 = require("perf_hooks");
@@ -84,4 +84,3 @@ async function main() {
     const endTime = perf_hooks_1.performance.now();
     (0, log_1.consoleLog)(`✨ Done in ${((endTime - startTime) / 1000).toFixed(2)}s.`);
 }
-exports.main = main;

package/dist/log.js

@@ -3,7 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consoleLogErrorAndExit = exports.consoleLogError = exports.consoleLogInfo = exports.consoleLog = void 0;
+exports.consoleLog = consoleLog;
+exports.consoleLogInfo = consoleLogInfo;
+exports.consoleLogError = consoleLogError;
+exports.consoleLogErrorAndExit = consoleLogErrorAndExit;
 const chalk_1 = __importDefault(require("chalk"));
 const util_1 = require("util");
 function getInspectArgs(args) {
@@ -23,17 +26,13 @@ function getInspectArgs(args) {
 function consoleLog(...args) {
     console.log(...getInspectArgs(args));
 }
-exports.consoleLog = consoleLog;
 function consoleLogInfo(...args) {
     console.log(`${chalk_1.default.cyanBright.bold('info')}`, ...getInspectArgs(args));
 }
-exports.consoleLogInfo = consoleLogInfo;
 function consoleLogError(...args) {
     console.log(`${chalk_1.default.redBright.bold('error')}`, ...getInspectArgs(args));
 }
-exports.consoleLogError = consoleLogError;
 function consoleLogErrorAndExit(...args) {
     consoleLogError(...args);
     process.exit(1);
 }
-exports.consoleLogErrorAndExit = consoleLogErrorAndExit;

package/dist/utils.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimArray = exports.quoteJavaScriptValue = exports.trimStringDoubleSpaces = exports.arrayToMap = exports.sortArrayAlphabetically = exports.uniqueArray = exports.capitalizeFirstLetter = exports.isObject = exports.isString = exports.flatten = void 0;
+exports.flatten = flatten;
+exports.isString = isString;
+exports.isObject = isObject;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.uniqueArray = uniqueArray;
+exports.sortArrayAlphabetically = sortArrayAlphabetically;
+exports.arrayToMap = arrayToMap;
+exports.trimStringDoubleSpaces = trimStringDoubleSpaces;
+exports.quoteJavaScriptValue = quoteJavaScriptValue;
+exports.trimArray = trimArray;
 function flatten(input) {
     const stack = [...input];
     const result = [];
@@ -17,27 +26,21 @@ function flatten(input) {
     }
     return result.reverse();
 }
-exports.flatten = flatten;
 function isString(object) {
     return typeof object === 'string';
 }
-exports.isString = isString;
 function isObject(object) {
     return Object.prototype.toString.call(object) === '[object Object]';
 }
-exports.isObject = isObject;
 function capitalizeFirstLetter(string) {
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
-exports.capitalizeFirstLetter = capitalizeFirstLetter;
 function uniqueArray(array) {
     return array.filter((v, i, a) => a.indexOf(v) === i);
 }
-exports.uniqueArray = uniqueArray;
 function sortArrayAlphabetically(array) {
     return array.sort((a, b) => a.localeCompare(b));
 }
-exports.sortArrayAlphabetically = sortArrayAlphabetically;
 function arrayToMap(array) {
     if (!array) {
         return {};
@@ -47,15 +50,12 @@ function arrayToMap(array) {
         return acc;
     }, {});
 }
-exports.arrayToMap = arrayToMap;
 function trimStringDoubleSpaces(string) {
     return string.trim().replace(/\s\s+/g, ' ');
 }
-exports.trimStringDoubleSpaces = trimStringDoubleSpaces;
 function quoteJavaScriptValue(value) {
     return isString(value) ? `'${value}'` : value;
 }
-exports.quoteJavaScriptValue = quoteJavaScriptValue;
 /**
  * Removes empty string array elements from start and end of array, trim array elements and returns the new array
  *
@@ -71,4 +71,3 @@ function trimArray(array) {
     }
     return trimmedArray;
 }
-exports.trimArray = trimArray;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@vkontakte/api-schema-typescript-generator",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "license": "MIT",
   "description": "VK API TypeScript generator",
   "author": {
     "name": "VK",
     "url": "https://vk.com"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "VK",
     "VK API",
@@ -46,13 +49,13 @@
   },
   "devDependencies": {
     "@types/jest": "^28.1.5",
-    "@types/node": "^18.17.3",
-    "@typescript-eslint/eslint-plugin": "5.30.6",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
     "@typescript-eslint/parser": "5.62.0",
     "@vkontakte/eslint-config": "3.1.0",
-    "eslint": "8.19.0",
-    "eslint-plugin-react": "7.33.1",
-    "eslint-plugin-react-hooks": "4.6.0",
+    "eslint": "8.57.1",
+    "eslint-plugin-react": "7.37.5",
+    "eslint-plugin-react-hooks": "5.0.0",
     "jest": "28.1.3",
     "pre-commit": "1.2.2",
     "rimraf": "^3.0.2",

package/src/generators/APITypingsGenerator.ts

@@ -382,14 +382,14 @@ export class APITypingsGenerator {
 
   private generateMethodParams(methodInfo: SchemaObject) {
     const section = getMethodSection(methodInfo.name);
-    const interfaceName = `${methodInfo.name} params`;
+    const interfaceName = getInterfaceName(`${methodInfo.name} params`);
 
     let imports: RefsDictionary = {};
     let codeBlocks: CodeBlocksArray = [];
 
     const codeBlock = new TypeCodeBlock({
       type: TypeScriptCodeTypes.Interface,
-      interfaceName: getInterfaceName(interfaceName),
+      interfaceName: interfaceName,
       needExport: true,
       allowEmptyInterface: true,
       properties: [],
@@ -417,6 +417,8 @@ export class APITypingsGenerator {
 
     this.appendToFileMap(section, imports, [...codeBlocks, codeBlock]);
     this.generateObjectsFromImports(imports);
+
+    return interfaceName;
   }
 
   private getResponseObjectRef(ref: string): SchemaObject | undefined {
@@ -543,7 +545,7 @@ export class APITypingsGenerator {
   public generateResponse(section: string, response: SchemaObject) {
     const result = this.getResponseCodeBlock(response);
     if (!result) {
-      return;
+      throw new Error('Unable to generate response');
     }
 
     const { codeBlocks, imports } = result;
@@ -578,16 +580,67 @@ export class APITypingsGenerator {
     method = normalizedMethod;
     this.generateObjectsFromRefs(parameterRefs);
 
-    this.generateMethodParams(new SchemaObject(method.name, method));
+    const methodParamsInterfaceName = this.generateMethodParams(
+      new SchemaObject(method.name, method),
+    );
 
-    Object.entries(method.responses).forEach(([responseName, responseObject]) => {
-      if (this.ignoredResponses[methodName] && this.ignoredResponses[methodName][responseName]) {
-        return;
-      }
+    const methodResponsesInterfaceName = Object.entries(method.responses)
+      .map(([responseName, responseObject]) => {
+        if (this.ignoredResponses[methodName] && this.ignoredResponses[methodName][responseName]) {
+          return;
+        }
+
+        const name = `${methodName}_${responseName}`;
+        const interfaceName = getInterfaceName(name);
+        try {
+          this.generateResponse(section, new SchemaObject(name, responseObject));
+          return interfaceName;
+        } catch (e) {
+          return;
+        }
+      })
+      .filter(Boolean) as string[];
+
+    this.generateMethodType(methodName, methodParamsInterfaceName, methodResponsesInterfaceName);
+  }
+
+  private generateMethodType(
+    methodName: string,
+    methodParamsInterfaceName: string,
+    methodResponsesInterfaceName: string[],
+  ) {
+    const codeBlock = new TypeCodeBlock({
+      type: TypeScriptCodeTypes.Interface,
+      interfaceName: getInterfaceName(`${methodName} method`),
+      needExport: true,
+      allowEmptyInterface: true,
+      properties: [],
+    });
+
+    codeBlock.addProperty({
+      name: 'method',
+      value: methodName,
+      isRequired: true,
+      wrapValue: true,
+    });
 
-      const name = `${methodName}_${responseName}`;
-      this.generateResponse(section, new SchemaObject(name, responseObject));
+    codeBlock.addProperty({
+      name: 'request',
+      value: methodParamsInterfaceName,
+      isRequired: true,
     });
+
+    codeBlock.addProperty({
+      name: 'response',
+      value:
+        methodResponsesInterfaceName.length > 0
+          ? methodResponsesInterfaceName.join(' | ')
+          : 'unknown',
+      isRequired: true,
+    });
+
+    const section = getMethodSection(methodName);
+    this.appendToFileMap(section, {}, [codeBlock]);
   }
 
   private generateMethods() {
@@ -601,11 +654,38 @@ export class APITypingsGenerator {
 
     Object.keys(this.methodFilesMap).forEach((section) => {
       const { imports, codeBlocks } = this.methodFilesMap[section];
+      const methodNames: string[] = [];
       codeBlocks.forEach((codeBlock) => {
         if (codeBlock instanceof TypeCodeBlock && codeBlock.needExport && codeBlock.interfaceName) {
+          /**
+           * for interfaceName structure
+           * @see this.generateMethodType
+           */
+          if (codeBlock.interfaceName.endsWith('Method')) {
+            methodNames.push(codeBlock.interfaceName);
+            // Skip export as it will be exported in union type
+            return;
+          }
+
           this.registerExport(`./methods/${section}`, codeBlock.interfaceName);
         }
       });
+
+      if (methodNames.length > 0) {
+        const sectionMethodsCodeBlock = new TypeCodeBlock({
+          type: TypeScriptCodeTypes.Type,
+          interfaceName: getInterfaceName(`${section} methods union`),
+          needExport: true,
+          allowEmptyInterface: true,
+          value: methodNames.join(' | '),
+          properties: [],
+        });
+
+        codeBlocks.push(sectionMethodsCodeBlock);
+
+        this.registerExport(`./methods/${section}`, sectionMethodsCodeBlock.interfaceName);
+      }
+
       const code = [generateImportsBlock(imports, null), ...codeBlocks];
 
       this.registerResultFile(
@@ -685,8 +765,23 @@ export class APITypingsGenerator {
       }).toString(),
     );
 
+    code.push(`
+type MethodOf<M> = M extends { method: string } ? M['method'] : never;
+type RequestOf<M> = M extends { request: unknown } ? M['request'] : never;
+type ResponseOf<M> = M extends { response: unknown } ? M['response'] : never;
+
+export type CreateMethodMap<Type extends { method: string }> = {
+  [Property in Type as Property['method']]: {
+    method: MethodOf<Property>;
+    request: RequestOf<Property>;
+    response: ResponseOf<Property>;
+  };
+};
+    `);
+
     this.registerExport('./common/common', 'API_VERSION');
     this.registerExport('./common/common', getInterfaceName(baseAPIParamsInterfaceName));
+    this.registerExport('./common/common', 'CreateMethodMap');
     this.registerResultFile(path.join('common', 'common.ts'), code.join(newLineChar.repeat(2)));
   }
 
@@ -698,6 +793,60 @@ export class APITypingsGenerator {
 
     const blocks: string[] = [];
     let exportedObjects: Dictionary<boolean> = {};
+    let methodNames = new Set<string>();
+
+    sortArrayAlphabetically(Object.keys(this.exports)).forEach((path) => {
+      if (!path.startsWith('./methods/')) {
+        return;
+      }
+
+      const objects = Object.keys(this.exports[path]);
+      if (!objects.length) {
+        return;
+      }
+
+      const blockLines: string[] = [];
+
+      sortArrayAlphabetically(objects).forEach((object) => {
+        /**
+         * for interfaceName structure
+         * @see this.generateMethods
+         */
+        if (!methodNames.has(object) && /^[A-Z][a-zA-Z0-9]*MethodsUnion$/.test(object)) {
+          methodNames.add(object);
+          exportedObjects[object] = true; // To skip in export block
+          blockLines.push(`  ${object},`);
+        }
+      });
+
+      if (blockLines.length > 0) {
+        blockLines.unshift('import type {');
+        blockLines.push(`} from '${path.replace('.ts', '')}';`);
+
+        blocks.push(blockLines.join(newLineChar));
+      }
+    });
+
+    blocks.push("import type { CreateMethodMap } from './common/common';");
+
+    const methodsCodeBlock = new TypeCodeBlock({
+      type: TypeScriptCodeTypes.Type,
+      interfaceName: 'ApiMethodsUnion',
+      needExport: false,
+      properties: [],
+      value: Array.from(methodNames).join(' | '),
+    });
+    blocks.push(methodsCodeBlock.toString());
+
+    blocks.push(
+      new TypeCodeBlock({
+        type: TypeScriptCodeTypes.Type,
+        interfaceName: 'ApiMethodsMap',
+        needExport: true,
+        properties: [],
+        value: `CreateMethodMap<${methodsCodeBlock.interfaceName}>`,
+      }).toString(),
+    );
 
     sortArrayAlphabetically(Object.keys(this.exports)).forEach((path) => {
       const objects = Object.keys(this.exports[path]);