@vkontakte/api-schema-typescript-generator 0.9.0 → 0.13.0

package/dist/generators/enums.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInlineEnum = exports.generateEnumAsUnionType = exports.generateEnumConstantObject = exports.getEnumNamesIdentifier = exports.isNumericEnum = void 0;
+const constants_1 = require("../constants");
+const helpers_1 = require("../helpers");
+const utils_1 = require("../utils");
+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 = helpers_1.getInterfaceName(objectName);
+    const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+        type: TypeCodeBlock_1.TypeScriptCodeTypes.ConstantObject,
+        refName: objectName,
+        interfaceName: enumInterfaceName,
+        needExport: true,
+        properties: [],
+    });
+    enumNames.forEach((name, index) => {
+        codeBlock.addProperty({
+            name: helpers_1.getEnumPropertyName(name.toString()),
+            value: object.enum[index],
+            wrapValue: true,
+        });
+    });
+    return codeBlock;
+}
+exports.generateEnumConstantObject = generateEnumConstantObject;
+/**
+ * Generates enum as union type with constant object if necessary
+ */
+function generateEnumAsUnionType(object) {
+    const { codeBlocks, value, description } = generateInlineEnum(object, {
+        refName: getEnumNamesIdentifier(object.name),
+    });
+    const unionType = 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),
+        needExport: true,
+        properties: [],
+        value,
+    });
+    codeBlocks.push(unionType);
+    return {
+        codeBlocks,
+        imports: {},
+        value: '',
+    };
+}
+exports.generateEnumAsUnionType = generateEnumAsUnionType;
+function getEnumNames(object) {
+    let { enumNames } = object;
+    const isNumeric = isNumericEnum(object);
+    const needEnumNamesDescription = !!enumNames;
+    if (!enumNames) {
+        const canUseEnumNames = !isNumeric;
+        if (canUseEnumNames) {
+            enumNames = [...object.enum];
+        }
+    }
+    return {
+        isNumericEnum: isNumeric,
+        needEnumNamesDescription,
+        enumNames: Array.isArray(enumNames) && enumNames.length ? enumNames : undefined,
+    };
+}
+function generateInlineEnum(object, options = {}) {
+    const { isNumericEnum, enumNames, needEnumNamesDescription, } = getEnumNames(object);
+    options = {
+        needEnumNamesConstant: isNumericEnum,
+        ...options,
+    };
+    const codeBlocks = [];
+    let descriptionLines = [];
+    if (enumNames) {
+        if (needEnumNamesDescription) {
+            if (isNumericEnum && options.refName) {
+                descriptionLines.push('');
+                descriptionLines.push('@note This enum have auto-generated constant with keys and values');
+                descriptionLines.push(`@see ${helpers_1.getInterfaceName(options.refName)}`);
+            }
+            descriptionLines.push('');
+            enumNames.forEach((name, index) => {
+                const value = object.enum[index];
+                if (needEnumNamesDescription) {
+                    descriptionLines.push(`\`${value}\` — ${name}`);
+                }
+            });
+        }
+        if (isNumericEnum && options.needEnumNamesConstant) {
+            const enumName = getEnumNamesIdentifier(`${options.objectParentName || ''} ${object.name}`);
+            const codeBlock = generateEnumConstantObject(object, enumName, enumNames);
+            codeBlocks.push(codeBlock);
+        }
+    }
+    const values = object.enum.map((value) => utils_1.quoteJavaScriptValue(value));
+    return {
+        codeBlocks,
+        imports: {},
+        value: helpers_1.joinOneOfValues(values, true),
+        description: descriptionLines.join(constants_1.newLineChar),
+    };
+}
+exports.generateInlineEnum = generateInlineEnum;

package/dist/generators/methods.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMethodInfo = void 0;
+const constants_1 = require("../constants");
+const helpers_1 = require("../helpers");
+const types_1 = require("../types");
+/**
+ * Patches for method definition
+ */
+function normalizeMethodInfo(method) {
+    const parameterRefs = {};
+    method.parameters?.forEach((parameter) => {
+        // For method params "boolean" type means 1 or 0
+        // Real "false" boolean value will be detected by API as true
+        if (parameter.type === 'boolean') {
+            delete parameter.type;
+            parameter.$ref = constants_1.baseBoolIntRef;
+        }
+        // For parameters of the "array" type, VK API still accepts only a comma-separated string
+        // This may change in the future when the VK API starts accepting a json body
+        if (parameter.type === 'array') {
+            parameter.type = 'string';
+        }
+        if (!parameter.description) {
+            parameter.description = '';
+        }
+        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);
+        }
+    });
+    return {
+        method,
+        parameterRefs,
+    };
+}
+exports.normalizeMethodInfo = normalizeMethodInfo;

package/dist/generators/typeString.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypeString = void 0;
-const helpers_1 = require("../helpers");
 const constants_1 = require("../constants");
-const utils_1 = require("../utils");
+const enums_1 = require("./enums");
+const helpers_1 = require("../helpers");
 const log_1 = require("../log");
-const generator_1 = require("../generator");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
 function generateBaseType(object, options) {
     let codeBlocks = [];
     let typeString = 'any /* default type */';
     let imports = {};
     let description = '';
     if (object.enum) {
-        const { value, codeBlocks: newCodeBlocks, description: newDescription, } = generator_1.generateInlineEnum(object, {
+        const { value, codeBlocks: newCodeBlocks, description: newDescription, } = enums_1.generateInlineEnum(object, {
             // TODO: Refactor
             // section_object_name -> property_name -> items => section_object_name_property_name_items enumNames
             objectParentName: options.objectParentName || object.parentObjectName,
-            skipEnumNamesConstant: options.skipEnumNamesConstant,
+            needEnumNamesConstant: options.needEnumNamesConstant,
         });
         typeString = value;
         codeBlocks = newCodeBlocks;
@@ -47,6 +48,10 @@ function generateTypeString(object, objects, options = {}) {
     let typeString = 'any /* default type */';
     let imports = {};
     let description = '';
+    options = {
+        needEnumNamesConstant: true,
+        ...options,
+    };
     if (object.oneOf) {
         const values = object.oneOf.map((oneOfObject) => {
             const { value, imports: newImports } = generateTypeString(oneOfObject, objects);
@@ -74,8 +79,8 @@ function generateTypeString(object, objects, options = {}) {
             if (!refObject) {
                 log_1.consoleLogErrorAndExit(`Error, object for "${refName}" ref is not found.`);
             }
-            imports[refName] = true;
-            typeString = helpers_1.getInterfaceName(refName) + '[]'.repeat(depth);
+            imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
+            typeString = helpers_1.formatArrayDepth(helpers_1.getInterfaceName(refName), depth);
         }
         else {
             const { value, description: newDescription, imports: newImports, codeBlocks: newCodeBlocks, } = generateBaseType(items, {
@@ -83,20 +88,12 @@ function generateTypeString(object, objects, options = {}) {
                 // TODO: Refactor
                 objectParentName: object.parentObjectName,
             });
-            if (value.endsWith('\'') || value.includes('|')) {
-                typeString = `Array<${value}>` + '[]'.repeat(depth - 1); // Need decrement depth value because of Array<T> has its own depth
-            }
-            else {
-                typeString = value + '[]'.repeat(depth);
-            }
+            typeString = helpers_1.formatArrayDepth(value, depth);
             description = newDescription;
             imports = { ...imports, ...newImports };
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
         }
     }
-    else if (object.type) {
-        return generateBaseType(object, options);
-    }
     else if (object.ref) {
         const refName = helpers_1.getObjectNameByRef(object.ref);
         switch (refName) {
@@ -113,7 +110,7 @@ function generateTypeString(object, objects, options = {}) {
                     log_1.consoleLogErrorAndExit(`Error, object for "${refName}" ref is not found.`);
                 }
                 if (refObject.enum) {
-                    imports[refName] = true;
+                    imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
                     typeString = helpers_1.getInterfaceName(refName);
                 }
                 else if (refObject.oneOf) {
@@ -128,12 +125,15 @@ function generateTypeString(object, objects, options = {}) {
                     typeString = constants_1.scalarTypes[refObject.type];
                 }
                 else {
-                    imports[refName] = true;
+                    imports[refName] = types_1.RefsDictionaryType.GenerateAndImport;
                     typeString = helpers_1.getInterfaceName(refName);
                 }
             }
         }
     }
+    else if (object.type) {
+        return generateBaseType(object, options);
+    }
     return {
         codeBlocks,
         imports,

package/dist/helpers.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePrimitiveTypesArray = exports.joinOneOfValues = 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.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;
 const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
@@ -137,6 +137,36 @@ function transformPatternPropertyName(name) {
     return '[key: string] /* default pattern property name */';
 }
 exports.transformPatternPropertyName = transformPatternPropertyName;
+function joinCommentLines(indent = 2, ...description) {
+    let descriptionLines = [];
+    description.forEach((entry) => {
+        if (typeof entry === 'string') {
+            descriptionLines = [
+                ...descriptionLines,
+                ...utils_1.trimArray((entry || '').trim().split(constants_1.newLineChar)),
+            ];
+        }
+        else if (Array.isArray(entry)) {
+            descriptionLines = [
+                ...descriptionLines,
+                ...entry,
+            ];
+        }
+    });
+    descriptionLines = utils_1.trimArray(descriptionLines);
+    if (!descriptionLines.length) {
+        return [];
+    }
+    const indentSpaces = constants_1.spaceChar.repeat(indent);
+    return [
+        `${indentSpaces}/**`,
+        ...descriptionLines.map((line) => {
+            return indentSpaces + ' ' + `* ${line}`.trim();
+        }),
+        `${indentSpaces} */`,
+    ];
+}
+exports.joinCommentLines = joinCommentLines;
 function joinOneOfValues(values, primitive) {
     const joined = values.join(' | ');
     if (joined.length > 120) {
@@ -148,6 +178,15 @@ function joinOneOfValues(values, primitive) {
     }
 }
 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
+    }
+    else {
+        return value + '[]'.repeat(depth);
+    }
+}
+exports.formatArrayDepth = formatArrayDepth;
 function resolvePrimitiveTypesArray(types) {
     const isEveryTypePrimitive = types.every((type) => !!constants_1.primitiveTypes[type]);
     if (isEveryTypePrimitive) {

package/dist/log.js

@@ -11,7 +11,7 @@ function getInspectArgs(args) {
         if (typeof arg === 'object') {
             return util_1.inspect(arg, {
                 showHidden: false,
-                depth: null,
+                depth: 10,
                 colors: true,
             });
         }

package/dist/types/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectType = void 0;
+exports.ObjectType = exports.RefsDictionaryType = void 0;
+var RefsDictionaryType;
+(function (RefsDictionaryType) {
+    RefsDictionaryType[RefsDictionaryType["GenerateAndImport"] = 0] = "GenerateAndImport";
+    RefsDictionaryType[RefsDictionaryType["Generate"] = 1] = "Generate";
+})(RefsDictionaryType = exports.RefsDictionaryType || (exports.RefsDictionaryType = {}));
 var ObjectType;
 (function (ObjectType) {
     ObjectType["Object"] = "object";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/api-schema-typescript-generator",
-  "version": "0.9.0",
+  "version": "0.13.0",
   "license": "MIT",
   "description": "VK API TypeScript generator",
   "author": {
@@ -31,6 +31,7 @@
   "scripts": {
     "clear": "rimraf dist/*",
     "build": "yarn clear && tsc",
+    "watch": "yarn clear && tsc --watch",
     "test": "tsc --noEmit && eslint src --ext .ts"
   },
   "pre-commit": [

package/src/generator.ts

@@ -1,16 +1,17 @@
-import { Dictionary, ObjectType } from './types';
-import { quoteJavaScriptValue, sortArrayAlphabetically, uniqueArray } from './utils';
 import { newLineChar } from './constants';
-import { getEnumPropertyName, getInterfaceName, getSectionFromObjectName, joinOneOfValues } from './helpers';
-import { CodeBlocksArray, GeneratorResultInterface } from './generators/BaseCodeBlock';
-import { TypeCodeBlock, TypeScriptCodeTypes } from './generators/TypeCodeBlock';
-import { SchemaObject } from './generators/SchemaObject';
+import { getInterfaceName, getSectionFromObjectName } from './helpers';
+import { Dictionary, ObjectType, RefsDictionary, RefsDictionaryType } from './types';
+import { sortArrayAlphabetically, uniqueArray } from './utils';
 
-export function generateImportsBlock(imports: Dictionary<boolean>, section: string | null, type?: ObjectType): string {
-  const objectsToImport = uniqueArray(Object.keys(imports));
-  const paths: Dictionary<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);
+
+  importRefs = uniqueArray(importRefs);
 
-  objectsToImport.forEach((objectName) => {
+  const paths: Dictionary<string[]> = {};
+  importRefs.forEach((objectName) => {
     const importSection = getSectionFromObjectName(objectName);
     const interfaceName = getInterfaceName(objectName);
     let path;
@@ -40,127 +41,3 @@ export function generateImportsBlock(imports: Dictionary<boolean>, section: stri
 
   return importLines.join(newLineChar);
 }
-
-function getEnumNames(object: SchemaObject) {
-  let { enumNames } = object;
-
-  const needEnumNamesDescription = !!enumNames;
-
-  if (!enumNames) {
-    const canUseEnumNames = !object.enum.some((value) => !!+value);
-    if (canUseEnumNames) {
-      enumNames = [...object.enum];
-    }
-  }
-
-  return {
-    needEnumNamesDescription,
-    enumNames: Array.isArray(enumNames) && enumNames.length ? enumNames : undefined,
-  };
-}
-
-interface GenerateInlineEnumOptions {
-  objectParentName?: string;
-  skipEnumNamesConstant?: boolean;
-}
-
-export function generateInlineEnum(object: SchemaObject, options: GenerateInlineEnumOptions = {}): GeneratorResultInterface {
-  const {
-    enumNames,
-    needEnumNamesDescription,
-  } = getEnumNames(object);
-
-  const codeBlocks: CodeBlocksArray = [];
-  let descriptionLines: string[] = [];
-
-  if (enumNames) {
-    const enumName = options.objectParentName ? `${options.objectParentName} ${object.name} enumNames` : object.name;
-    const enumInterfaceName = getInterfaceName(enumName);
-
-    const codeBlock = new TypeCodeBlock({
-      type: TypeScriptCodeTypes.ConstantObject,
-      refName: enumName,
-      interfaceName: enumInterfaceName,
-      needExport: true,
-      properties: [],
-    });
-
-    if (needEnumNamesDescription) {
-      descriptionLines.push('');
-    }
-
-    enumNames.forEach((name, index) => {
-      const value = object.enum[index];
-
-      codeBlock.addProperty({
-        name: getEnumPropertyName(name.toString()),
-        value,
-        wrapValue: true,
-      });
-
-      if (needEnumNamesDescription) {
-        descriptionLines.push(`\`${value}\` — ${name}`);
-      }
-    });
-
-    if (!options.skipEnumNamesConstant) {
-      codeBlocks.push(codeBlock);
-    }
-  }
-
-  const values = object.enum.map((value) => quoteJavaScriptValue(value));
-
-  return {
-    codeBlocks,
-    imports: {},
-    value: joinOneOfValues(values, true),
-    description: descriptionLines.join(newLineChar),
-  };
-}
-
-interface GenerateStandaloneEnumOptions {
-  objectParentName?: string;
-}
-
-export function generateStandaloneEnum(object: SchemaObject, options: GenerateStandaloneEnumOptions = {}): GeneratorResultInterface {
-  const {
-    enumNames,
-  } = getEnumNames(object);
-
-  if (enumNames) {
-    const enumName = options.objectParentName ? `${options.objectParentName} ${object.name} enum` : object.name;
-    const enumInterfaceName = getInterfaceName(enumName);
-
-    const codeBlock = new TypeCodeBlock({
-      type: TypeScriptCodeTypes.Enum,
-      refName: enumName,
-      interfaceName: enumInterfaceName,
-      needExport: true,
-      properties: [],
-    });
-
-    enumNames.forEach((name, index) => {
-      codeBlock.addProperty({
-        name: getEnumPropertyName(name.toString()),
-        value: object.enum[index],
-        wrapValue: true,
-      });
-    });
-
-    return {
-      codeBlocks: [
-        codeBlock,
-      ],
-      imports: {},
-      value: enumInterfaceName,
-    };
-  } else {
-    const values = object.enum.map((value) => quoteJavaScriptValue(value));
-
-    return {
-      codeBlocks: [],
-      imports: {},
-      value: joinOneOfValues(values, true),
-    };
-  }
-}