jswagger-generator/lib/definition-interface-generator/v3.js

This is jswagger's generator package.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const property_mapper_1 = require("../property-mapper");
const utils_1 = require("../utils");
exports.PRIMITIVES = {
    // boolean types
    boolean: 'boolean',
    // string types
    string: 'string',
    // number types
    integer: 'number',
    number: 'number',
};
function generateTypesV3(schema, options) {
    if (!schema.components || !schema.components.schemas) {
        throw new Error('⛔️ \'components\' missing from schema https://swagger.io/specification');
    }
    // propertyMapper
    const propertyMapped = options
        ? property_mapper_1.default(schema.components.schemas, options.propertyMapper)
        : schema.components.schemas;
    // type converter
    function transform(node) {
        switch (utils_1.nodeType(node)) {
            case 'ref': {
                return utils_1.transformRef(node.$ref);
            }
            case 'string':
            case 'number':
            case 'boolean': {
                return utils_1.nodeType(node) || 'any';
            }
            case 'enum': {
                return utils_1.tsUnionOf(node.enum.map((item) => `'${item}'`));
            }
            case 'oneOf': {
                return utils_1.tsUnionOf(node.oneOf.map(transform));
            }
            case 'anyOf': {
                return utils_1.tsIntersectionOf(node.anyOf.map((anyOf) => utils_1.tsPartial(transform(anyOf))));
            }
            case 'object': {
                // if empty object, then return generic map type
                if ((!node.properties || !Object.keys(node.properties).length) &&
                    !node.allOf &&
                    !node.additionalProperties) {
                    return '{ [key: string]: any }';
                }
                let properties = createKeys(node.properties || {}, node.required);
                // if additional properties, add to end of properties
                if (node.additionalProperties) {
                    properties += `[key: string]: ${utils_1.nodeType(node.additionalProperties) || 'any'};\n`;
                }
                return utils_1.tsIntersectionOf([
                    ...(node.allOf ? node.allOf.map(transform) : []),
                    ...(properties ? [`{ ${properties} }`] : []),
                ]);
            }
            case 'array': {
                return utils_1.tsArrayOf(transform(node.items));
            }
        }
        return '';
    }
    function createKeys(obj, required) {
        let output = '';
        Object.entries(obj).forEach(([key, value]) => {
            // 1. JSDoc comment (goes above property)
            if (value.description) {
                output += utils_1.comment(value.description);
            }
            // 2. name (with “?” if optional property)
            output += `"${key}"${!required || !required.includes(key) ? '?' : ''}: `;
            // 3. open nullable
            if (value.nullable) {
                output += '(';
            }
            // 4. transform
            output += transform(value);
            // 5. close nullable
            if (value.nullable) {
                output += ') | null';
            }
            // 6. close type
            output += ';\n';
        });
        return output;
    }
    // note: make sure that base-level schemas are required
    return `export interface components {
    schemas: {
      ${createKeys(propertyMapped, Object.keys(propertyMapped))}
    }
  }`;
}
exports.default = generateTypesV3;