swagger-typescript-api 11.1.3 → 12.0.1

package/src/schema-parser/schema-parser.js

@@ -2,6 +2,9 @@ const { SCHEMA_TYPES } = require("../constants.js");
 const _ = require("lodash");
 const { SchemaFormatters } = require("./schema-formatters");
 const { internalCase } = require("../util/internal-case");
+const { SchemaUtils } = require("./schema-utils");
+const { camelCase } = require("lodash");
+const { pascalCase } = require("../util/pascal-case");
 
 class SchemaParser {
   /**
@@ -22,42 +25,53 @@ class SchemaParser {
    */
   schemaFormatters;
 
+  /**
+   * @type {SchemaUtils}
+   */
+  schemaUtils;
+
+  $processingSchemaPath = [];
+
   constructor(config, logger, templates, schemaComponentsMap, typeName) {
     this.config = config;
     this.schemaComponentsMap = schemaComponentsMap;
     this.typeName = typeName;
     this.schemaFormatters = new SchemaFormatters(config, logger, this, templates);
+    this.schemaUtils = new SchemaUtils(config, schemaComponentsMap);
   }
 
   complexSchemaParsers = {
     // T1 | T2
     [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
+      const ignoreTypes = [this.config.Ts.Keyword.Any];
       const combined = _.map(schema.oneOf, (childSchema) =>
-        this.getInlineParseContent(this.makeAddRequiredToChildSchema(schema, childSchema)),
+        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
       );
-      const filtered = this.filterContents(combined, [this.config.Ts.Keyword.Any]);
+      const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
       const type = this.config.Ts.UnionType(filtered);
 
-      return this.checkAndAddNull(schema, type);
+      return this.schemaUtils.safeAddNullToType(schema, type);
     },
     // T1 & T2
     [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
+      const ignoreTypes = [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any];
       const combined = _.map(schema.allOf, (childSchema) =>
-        this.getInlineParseContent(this.makeAddRequiredToChildSchema(schema, childSchema)),
+        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
       );
-      const filtered = this.filterContents(combined, [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any]);
+      const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
       const type = this.config.Ts.IntersectionType(filtered);
 
-      return this.checkAndAddNull(schema, type);
+      return this.schemaUtils.safeAddNullToType(schema, type);
     },
     // T1 | T2 | (T1 & T2)
     [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
+      const ignoreTypes = [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any];
       const combined = _.map(schema.anyOf, (childSchema) =>
-        this.getInlineParseContent(this.makeAddRequiredToChildSchema(schema, childSchema)),
+        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
       );
-      const filtered = this.filterContents(combined, [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any]);
+      const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
       const type = this.config.Ts.UnionType(
         _.compact([
@@ -66,7 +80,7 @@ class SchemaParser {
         ]),
       );
 
-      return this.checkAndAddNull(schema, type);
+      return this.schemaUtils.safeAddNullToType(schema, type);
     },
     // TODO
     [SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
@@ -77,23 +91,39 @@ class SchemaParser {
 
   baseSchemaParsers = {
     [SCHEMA_TYPES.ENUM]: (schema, typeName) => {
-      const refType = this.getRefType(schema);
+      if (this.config.extractEnums && !typeName) {
+        const generatedTypeName = this.config.componentTypeNameResolver.resolve([this.buildTypeNameFromPath()]);
+        const schemaComponent = this.schemaComponentsMap.createComponent("schemas", generatedTypeName, { ...schema });
+        return this.parseSchema(schemaComponent, generatedTypeName);
+      }
+
+      const refType = this.schemaUtils.getSchemaRefType(schema);
       const $ref = (refType && refType.$ref) || null;
-      const enumNamesAsValues = this.config.enumNamesAsValues;
-      const keyType = this.getType(schema);
-      const enumNames = this.getEnumNames(schema);
-      const isIntegerOrBooleanEnum =
-        keyType === this.getTypeAlias({ type: "number" }) || keyType === this.getTypeAlias({ type: "boolean" });
+
+      if (Array.isArray(schema.enum) && Array.isArray(schema.enum[0])) {
+        return this.parseSchema(
+          {
+            oneOf: schema.enum.map((enumNames) => ({
+              type: "array",
+              items: enumNames.map((enumName) => ({ type: "string", enum: [enumName] })),
+            })),
+          },
+          typeName,
+        );
+      }
+
+      const keyType = this.getSchemaType(schema);
+      const enumNames = this.schemaUtils.getEnumNames(schema);
       let content = null;
 
       const formatValue = (value) => {
         if (value === null) {
           return this.config.Ts.NullValue(value);
         }
-        if (keyType === this.getTypeAlias({ type: "number" })) {
+        if (keyType === this.getSchemaType({ type: "number" })) {
           return this.config.Ts.NumberValue(value);
         }
-        if (keyType === this.getTypeAlias({ type: "boolean" })) {
+        if (keyType === this.getSchemaType({ type: "boolean" })) {
           return this.config.Ts.BooleanValue(value);
         }
 
@@ -104,10 +134,15 @@ class SchemaParser {
         content = _.map(enumNames, (enumName, index) => {
           const enumValue = _.get(schema.enum, index);
           const formattedKey =
-            (enumName && this.typeName.format(enumName, { ignorePrefix: true, ignoreSuffix: true })) ||
-            this.typeName.format(enumValue, { ignorePrefix: true, ignoreSuffix: true });
-
-          if (enumNamesAsValues || _.isUndefined(enumValue)) {
+            (enumName &&
+              this.typeName.format(enumName, {
+                type: "enum-key",
+              })) ||
+            this.typeName.format(`${enumValue}`, {
+              type: "enum-key",
+            });
+
+          if (this.config.enumNamesAsValues || _.isUndefined(enumValue)) {
             return {
               key: formattedKey,
               type: this.config.Ts.Keyword.String,
@@ -124,14 +159,16 @@ class SchemaParser {
       } else {
         content = _.map(schema.enum, (key) => {
           return {
-            key: isIntegerOrBooleanEnum ? key : this.typeName.format(key, { ignorePrefix: true, ignoreSuffix: true }),
+            key: this.typeName.format(`${key}`, {
+              type: "enum-key",
+            }),
             type: keyType,
             value: formatValue(key),
           };
         });
       }
 
-      return this.attachParsedRef(schema, {
+      return {
         ...(_.isObject(schema) ? schema : {}),
         $ref: $ref,
         typeName: typeName || ($ref && refType.typeName) || null,
@@ -139,19 +176,16 @@ class SchemaParser {
         schemaType: SCHEMA_TYPES.ENUM,
         type: SCHEMA_TYPES.ENUM,
         keyType: keyType,
-        typeIdentifier:
-          this.config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum)
-            ? this.config.Ts.Keyword.Type
-            : this.config.Ts.Keyword.Enum,
+        typeIdentifier: this.config.generateUnionEnums ? this.config.Ts.Keyword.Type : this.config.Ts.Keyword.Enum,
         name: typeName,
         description: this.schemaFormatters.formatDescription(schema.description),
         content,
-      });
+      };
     },
     [SCHEMA_TYPES.OBJECT]: (schema, typeName) => {
       const contentProperties = this.getObjectSchemaContent(schema);
 
-      return this.attachParsedRef(schema, {
+      return {
         ...(_.isObject(schema) ? schema : {}),
         $parsedSchema: true,
         schemaType: SCHEMA_TYPES.OBJECT,
@@ -161,14 +195,14 @@ class SchemaParser {
         description: this.schemaFormatters.formatDescription(schema.description),
         allFieldsAreOptional: !_.some(_.values(contentProperties), (part) => part.isRequired),
         content: contentProperties,
-      });
+      };
     },
     [SCHEMA_TYPES.COMPLEX]: (schema, typeName) => {
       const complexType = this.getComplexType(schema);
       const simpleSchema = _.omit(_.clone(schema), _.keys(this.complexSchemaParsers));
       const complexSchemaContent = this.complexSchemaParsers[complexType](schema);
 
-      return this.attachParsedRef(schema, {
+      return {
         ...(_.isObject(schema) ? schema : {}),
         $parsedSchema: true,
         schemaType: SCHEMA_TYPES.COMPLEX,
@@ -186,11 +220,11 @@ class SchemaParser {
                 this.config.Ts.ExpressionGroup(this.getInlineParseContent(simpleSchema)),
             ]),
           ) || this.config.Ts.Keyword.Any,
-      });
+      };
     },
     [SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
       let contentType = null;
-      const { additionalProperties, type, description, $$requiredKeys } = schema || {};
+      const { additionalProperties, type, description, items } = schema || {};
 
       if (type === this.config.Ts.Keyword.Object && additionalProperties) {
         const fieldType = _.isObject(additionalProperties)
@@ -206,7 +240,11 @@ class SchemaParser {
         });
       }
 
-      return this.attachParsedRef(schema, {
+      if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
+        contentType = this.config.Ts.Tuple(items.map((item) => this.getInlineParseContent(item)));
+      }
+
+      return {
         ...(_.isObject(schema) ? schema : {}),
         $parsedSchema: true,
         schemaType: SCHEMA_TYPES.PRIMITIVE,
@@ -215,192 +253,67 @@ class SchemaParser {
         name: typeName,
         description: this.schemaFormatters.formatDescription(description),
         // TODO: probably it should be refactored. `type === 'null'` is not flexible
-        content: type === this.config.Ts.Keyword.Null ? type : contentType || this.getType(schema),
-      });
-    },
-  };
-
-  filterContents = (contents, types) => _.uniq(_.filter(contents, (type) => !_.includes(types, type)));
-
-  makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
-    if (!childSchema) return childSchema;
-
-    const required = _.uniq([...(parentSchema.required || []), ...(childSchema.required || [])]);
-
-    const refData = this.getRefType(childSchema);
-
-    if (refData) {
-      const refObjectProperties = _.keys((refData.rawTypeData && refData.rawTypeData.properties) || {});
-      const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
-
-      if (!existedRequiredKeys.length) return childSchema;
-
-      return {
-        ...childSchema,
-        $$requiredKeys: existedRequiredKeys,
+        content: type === this.config.Ts.Keyword.Null ? type : contentType || this.getSchemaType(schema),
       };
-    } else if (childSchema.properties) {
-      const childSchemaProperties = _.keys(childSchema.properties);
-      const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
-
-      if (!existedRequiredKeys.length) return childSchema;
-
-      return {
-        required: _.uniq([...(childSchema.required || []), ...existedRequiredKeys]),
-        ...childSchema,
-      };
-    }
-
-    return childSchema;
-  };
-
-  attachParsedRef = (originalSchema, parsedSchema) => {
-    const parsedSchemaAfterHook = this.config.hooks.onParseSchema(originalSchema, parsedSchema) || parsedSchema;
-
-    if (originalSchema) {
-      originalSchema.$parsed = parsedSchemaAfterHook;
-    }
-
-    return parsedSchemaAfterHook;
-  };
-
-  stealTypeFromSchema = (rawSchema) => {
-    const schema = rawSchema || {};
-
-    if (schema.type) {
-      return schema.type;
-    }
-    if (schema.enum) {
-      const enumFieldType = typeof schema.enum[0];
-      if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
-
-      return enumFieldType;
-    }
-    if (_.keys(schema.properties).length) {
-      return SCHEMA_TYPES.OBJECT;
-    }
-    if (!!schema.items) {
-      return SCHEMA_TYPES.ARRAY;
-    }
-  };
-
-  getTypeAlias = (rawSchema) => {
-    const schema = rawSchema || {};
-    const type = internalCase(this.stealTypeFromSchema(schema));
-    const typeAlias =
-      _.get(this.config.primitiveTypes, [type, schema.format]) ||
-      _.get(this.config.primitiveTypes, [type, "$default"]) ||
-      this.config.primitiveTypes[type];
-
-    if (_.isFunction(typeAlias)) {
-      return typeAlias(schema, this);
-    }
-
-    return typeAlias || type;
-  };
-
-  getEnumNames = (schema) => {
-    return schema["x-enumNames"] || schema["xEnumNames"] || schema["x-enumnames"] || schema["x-enum-varnames"];
+    },
   };
 
   getInternalSchemaType = (schema) => {
-    if (!_.isEmpty(schema.enum) || !_.isEmpty(this.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
+    if (!_.isEmpty(schema.enum) || !_.isEmpty(this.schemaUtils.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
     if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES.COMPLEX;
     if (!_.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
 
     return SCHEMA_TYPES.PRIMITIVE;
   };
 
-  isNeedToAddNull = (contract, value) => {
-    const { nullable, type } = contract || {};
-    return (
-      (nullable || !!_.get(contract, "x-nullable") || type === this.config.Ts.Keyword.Null) &&
-      (!_.isString(value) ||
-        (!value.includes(` ${this.config.Ts.Keyword.Null}`) && !value.includes(`${this.config.Ts.Keyword.Null} `)))
-    );
-  };
-
-  checkAndAddRequiredKeys = (schema, resultType) => {
-    if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
-      this.config.update({
-        internalTemplateOptions: {
-          addUtilRequiredKeysType: true,
-        },
-      });
-      return this.config.Ts.TypeWithGeneric(this.config.Ts.CodeGenKeyword.UtilRequiredKeys, [
-        resultType,
-        this.config.Ts.UnionType(schema.$$requiredKeys.map(this.config.Ts.StringValue)),
-      ]);
-    }
-
-    return resultType;
-  };
-
-  checkAndAddNull = (schema, value) => {
-    const { nullable, type } = schema || {};
-    return (nullable || !!_.get(schema, "x-nullable") || type === this.config.Ts.Keyword.Null) &&
-      _.isString(value) &&
-      !value.includes(` ${this.config.Ts.Keyword.Null}`) &&
-      !value.includes(`${this.config.Ts.Keyword.Null} `)
-      ? this.config.Ts.UnionType([value, this.config.Ts.Keyword.Null])
-      : value;
-  };
-
-  isRef = (property) => {
-    return !!(property && property["$ref"]);
-  };
-
-  getRefType = (schema) => {
-    const ref = schema && schema["$ref"];
-    return this.schemaComponentsMap.get(ref);
-  };
-
-  getType = (schema) => {
+  getSchemaType = (schema) => {
     if (!schema) return this.config.Ts.Keyword.Any;
 
-    const refTypeInfo = this.getRefType(schema);
+    const refTypeInfo = this.schemaUtils.getSchemaRefType(schema);
 
     if (refTypeInfo) {
-      return this.checkAndAddRequiredKeys(
+      return this.schemaUtils.checkAndAddRequiredKeys(
         schema,
-        this.checkAndAddNull(schema, this.typeName.format(refTypeInfo.typeName)),
+        this.schemaUtils.safeAddNullToType(schema, this.typeName.format(refTypeInfo.typeName)),
       );
     }
 
-    const primitiveType = this.getTypeAlias(schema);
-    return primitiveType
-      ? this.checkAndAddRequiredKeys(schema, this.checkAndAddNull(schema, primitiveType))
-      : this.config.Ts.Keyword.Any;
-  };
+    const primitiveType = this.schemaUtils.getSchemaPrimitiveType(schema);
 
-  isRequired = (property, name, requiredProperties) => {
-    if (property["x-omitempty"] === false) {
-      return true;
-    }
+    if (primitiveType == null) return this.config.Ts.Keyword.Any;
 
-    const isRequired = _.isBoolean(property.required)
-      ? !!property.required
-      : _.isArray(requiredProperties)
-      ? requiredProperties.includes(name)
-      : !!requiredProperties;
+    let resultType;
 
-    if (this.config.convertedFromSwagger2) {
-      return typeof property.nullable === this.config.Ts.Keyword.Undefined ? isRequired : !property.nullable;
+    const typeAlias =
+      _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
+      _.get(this.config.primitiveTypes, [primitiveType, "$default"]) ||
+      this.config.primitiveTypes[primitiveType];
+
+    if (_.isFunction(typeAlias)) {
+      resultType = typeAlias(schema, this);
+    } else {
+      resultType = typeAlias || primitiveType;
     }
-    return isRequired;
+
+    if (!resultType) return this.config.Ts.Keyword.Any;
+
+    return this.schemaUtils.checkAndAddRequiredKeys(schema, this.schemaUtils.safeAddNullToType(schema, resultType));
   };
 
   getObjectSchemaContent = (schema) => {
-    const { properties, additionalProperties, required: requiredProperties } = schema || {};
+    const { properties, additionalProperties } = schema || {};
 
     const propertiesContent = _.map(properties, (property, name) => {
-      const required = this.isRequired(property, name, requiredProperties);
-      const rawTypeData = _.get(this.getRefType(property), "rawTypeData", {});
+      this.$processingSchemaPath.push(name);
+      const required = this.schemaUtils.isPropertyRequired(name, property, schema);
+      const rawTypeData = _.get(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
       const nullable = !!(rawTypeData.nullable || property.nullable);
       const fieldName = this.typeName.isValidName(name) ? name : this.config.Ts.StringValue(name);
       const fieldValue = this.getInlineParseContent(property);
       const readOnly = property.readOnly;
 
+      this.$processingSchemaPath.pop();
+
       return {
         ...property,
         $$raw: property,
@@ -453,7 +366,7 @@ class SchemaParser {
    * @param formatter {"inline" | "base"}
    * @return {Record<string, any>}
    */
-  parseSchema = (schema, typeName, formatter) => {
+  parseSchema = (schema, typeName = null) => {
     if (!schema) return this.baseSchemaParsers[SCHEMA_TYPES.PRIMITIVE](null, typeName);
 
     let schemaType = null;
@@ -463,33 +376,47 @@ class SchemaParser {
       return schema;
     }
 
-    if (schema.$parsed) {
-      schemaType = schema.$parsed.schemaType;
-      parsedSchema = schema.$parsed;
-    } else {
-      if (!typeName && this.isRef(schema)) {
-        typeName = this.getType(schema);
+    if (!schema.$parsed) {
+      if (!typeName && this.schemaUtils.isRefSchema(schema)) {
+        typeName = this.getSchemaType(schema);
       }
 
-      if (schema.items && !schema.type) {
+      if (schema.items && !Array.isArray(schema.items) && !schema.type) {
         schema.type = SCHEMA_TYPES.ARRAY;
       }
-
       schemaType = this.getInternalSchemaType(schema);
+
+      this.$processingSchemaPath.push(typeName);
+
+      _.merge(schema, this.config.hooks.onPreParseSchema(schema, typeName, schemaType));
       parsedSchema = this.baseSchemaParsers[schemaType](schema, typeName);
+      schema.$parsed = this.config.hooks.onParseSchema(schema, parsedSchema) || parsedSchema;
     }
 
-    const formatterFn =
-      formatter in this.schemaFormatters &&
-      this.schemaFormatters[formatter] &&
-      this.schemaFormatters[formatter][schemaType];
+    this.$processingSchemaPath.pop();
 
-    return (formatterFn && formatterFn(parsedSchema)) || parsedSchema;
+    return schema.$parsed;
   };
 
-  getInlineParseContent = (rawTypeData, typeName = null) => this.parseSchema(rawTypeData, typeName, "inline").content;
+  getInlineParseContent = (rawTypeData, typeName) => {
+    const parsedSchema = this.parseSchema(rawTypeData, typeName);
+    const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "inline");
+    return formattedSchema.content;
+  };
 
-  getParseContent = (rawTypeData, typeName = null) => this.parseSchema(rawTypeData, typeName).content;
+  getParseContent = (rawTypeData, typeName) => {
+    const parsedSchema = this.parseSchema(rawTypeData, typeName);
+    const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "base");
+    return formattedSchema.content;
+  };
+
+  buildTypeNameFromPath = () => {
+    const schemaPath = _.uniq(_.compact(this.$processingSchemaPath));
+
+    if (!schemaPath || !schemaPath[0]) return null;
+
+    return internalCase(camelCase(`${schemaPath[0]}_${schemaPath[schemaPath.length - 1]}`));
+  };
 }
 
 module.exports = {