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

package/src/generators/APITypingsGenerator.ts

@@ -31,6 +31,7 @@ import { consoleLogError, consoleLogErrorAndExit, consoleLogInfo } from '../log'
 import { generateImportsBlock } from '../generator';
 import { generateTypeString } from './typeString';
 import { ErrorInterface } from '../types/schema';
+import { mergeImports } from './utils/mergeImports';
 
 interface APITypingsGeneratorOptions {
   needEmit: boolean;
@@ -131,10 +132,7 @@ export class APITypingsGenerator {
     };
 
     this.methodFilesMap[section] = {
-      imports: {
-        ...methodFile.imports,
-        ...imports,
-      },
+      imports: mergeImports(methodFile.imports, imports),
       codeBlocks: [...methodFile.codeBlocks, ...codeBlocks],
     };
   }
@@ -253,7 +251,7 @@ export class APITypingsGenerator {
         objectParentName: object.name,
       });
 
-      imports = { ...imports, ...newImports };
+      imports = mergeImports(imports, newImports);
       codeBlocks = [...codeBlocks, ...newCodeBlocks];
 
       codeBlock.addProperty({
@@ -297,7 +295,7 @@ export class APITypingsGenerator {
 
     let result: GeneratorResultInterface | false = false;
 
-    if (object.ref) {
+    if (object.ref && object.type === 'object') {
       result = this.getPrimitiveInterfaceCode(object);
     } else {
       switch (object.type) {
@@ -384,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: [],
@@ -406,7 +404,7 @@ export class APITypingsGenerator {
         needEnumNamesConstant: false,
       });
 
-      imports = { ...imports, ...newImports };
+      imports = mergeImports(imports, newImports);
       codeBlocks = [...codeBlocks, ...newCodeBlocks];
 
       codeBlock.addProperty({
@@ -419,6 +417,8 @@ export class APITypingsGenerator {
 
     this.appendToFileMap(section, imports, [...codeBlocks, codeBlock]);
     this.generateObjectsFromImports(imports);
+
+    return interfaceName;
   }
 
   private getResponseObjectRef(ref: string): SchemaObject | undefined {
@@ -545,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;
@@ -580,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: [],
+    });
 
-      const name = `${methodName}_${responseName}`;
-      this.generateResponse(section, new SchemaObject(name, responseObject));
+    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 = getMethodSection(methodName);
+    this.appendToFileMap(section, {}, [codeBlock]);
   }
 
   private generateMethods() {
@@ -603,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(
@@ -687,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)));
   }
 
@@ -700,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]);

package/src/generators/typeString.ts

@@ -19,6 +19,7 @@ import { Dictionary, RefsDictionary, RefsDictionaryType } from '../types';
 import { isString } from '../utils';
 import { CodeBlocksArray, GeneratorResultInterface } from './BaseCodeBlock';
 import { SchemaObject } from './SchemaObject';
+import { mergeImports } from './utils/mergeImports';
 
 interface GenerateTypeStringOptions {
   objectParentName?: string;
@@ -92,7 +93,7 @@ export function generateTypeString(
   if (object.oneOf) {
     const values = object.oneOf.map((oneOfObject) => {
       const { value, imports: newImports } = generateTypeString(oneOfObject, objects);
-      imports = { ...imports, ...newImports };
+      imports = mergeImports(imports, newImports);
       return value;
     });
 
@@ -134,7 +135,7 @@ export function generateTypeString(
 
       typeString = formatArrayDepth(value, depth);
       description = newDescription;
-      imports = { ...imports, ...newImports };
+      imports = mergeImports(imports, newImports);
       codeBlocks = [...codeBlocks, ...newCodeBlocks];
     }
   } else if (object.ref) {
@@ -162,13 +163,16 @@ export function generateTypeString(
         } else if (refObject.oneOf) {
           const values = refObject.oneOf.map((oneOfObject) => {
             const { value, imports: newImports } = generateTypeString(oneOfObject, objects);
-            imports = { ...imports, ...newImports };
+            imports = mergeImports(imports, newImports);
             return value;
           });
 
           typeString = joinOneOfValues(values);
         } else if (isString(refObject.type) && scalarTypes[refObject.type] && !refObject.ref) {
           typeString = scalarTypes[refObject.type];
+        } else if (object.type === PropertyType.STRING) {
+          imports[refName] = RefsDictionaryType.Generate;
+          typeString = scalarTypes.string;
         } else {
           imports[refName] = RefsDictionaryType.GenerateAndImport;
           typeString = getInterfaceName(refName);

package/src/generators/utils/mergeImports.ts

@@ -0,0 +1,17 @@
+import { RefsDictionary, RefsDictionaryType } from '../../types';
+
+export function mergeImports(oldImports: RefsDictionary, newImports: RefsDictionary) {
+  const result = { ...oldImports };
+
+  Object.entries(newImports).forEach(([name, newImportValue]) => {
+    const oldImportValue = oldImports[name];
+
+    if (oldImportValue === RefsDictionaryType.GenerateAndImport) {
+      return;
+    }
+
+    result[name] = newImportValue;
+  });
+
+  return result;
+}