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

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: '',
     };
@@ -300,27 +297,27 @@ export class APITypingsGenerator {
 
     let result: GeneratorResultInterface | false = false;
 
-    if (!object.type && object.ref) {
+    if (object.ref) {
       result = this.getPrimitiveInterfaceCode(object);
-    }
-
-    switch (object.type) {
-      case 'object':
-        result = this.getObjectInterfaceCode(object);
-        break;
-
-      case 'string':
-      case 'number':
-      case 'integer':
-      case 'array':
-      case 'boolean':
-        result = this.getPrimitiveInterfaceCode(object);
-        break;
-
-      default:
-        if (!result) {
-          consoleLogErrorAndExit(getInterfaceName(object.name), 'Unknown type of object', object);
-        }
+    } else {
+      switch (object.type) {
+        case 'object':
+          result = this.getObjectInterfaceCode(object);
+          break;
+
+        case 'string':
+        case 'number':
+        case 'integer':
+        case 'array':
+        case 'boolean':
+          result = this.getPrimitiveInterfaceCode(object);
+          break;
+
+        default:
+          if (!result) {
+            consoleLogErrorAndExit(getInterfaceName(object.name), 'Unknown type of object', object);
+          }
+      }
     }
 
     if (!result) {
@@ -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 = {};