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

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;