swagger-typescript-api 13.0.0-experimental-1 → 13.0.0

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

@@ -1,47 +1,58 @@
-const _ = require("lodash");
-const { SCHEMA_TYPES } = require("../constants");
-const { internalCase } = require("../util/internal-case");
-const { pascalCase } = require("../util/pascal-case");
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../constants');
+const { internalCase } = require('../util/internal-case');
+const { pascalCase } = require('../util/pascal-case');
+const { camelCase } = require('lodash');
 
 class SchemaUtils {
-  /**
-   * @type {CodeGenConfig}
-   */
+  /** @type {CodeGenConfig} */
   config;
-  /**
-   * @type {SchemaComponentsMap}
-   */
+  /** @type {SchemaComponentsMap} */
   schemaComponentsMap;
-  /**
-   * @type {TypeNameFormatter}
-   */
+  /** @type {TypeNameFormatter} */
   typeNameFormatter;
-
-  constructor(config, schemaComponentsMap, typeNameFormatter) {
+  /** @type {SchemaWalker} */
+  schemaWalker;
+
+  constructor({
+    config,
+    schemaComponentsMap,
+    typeNameFormatter,
+    schemaWalker,
+  }) {
     this.config = config;
     this.schemaComponentsMap = schemaComponentsMap;
     this.typeNameFormatter = typeNameFormatter;
+    this.schemaWalker = schemaWalker;
   }
 
   getRequiredProperties = (schema) => {
-    return _.uniq((schema && _.isArray(schema.required) && schema.required) || []);
+    return _.uniq(
+      (schema && _.isArray(schema.required) && schema.required) || [],
+    );
   };
 
   isRefSchema = (schema) => {
-    return !!(schema && schema["$ref"]);
+    return !!(schema && schema['$ref']);
   };
 
   getEnumNames = (schema) => {
-    return schema["x-enumNames"] || schema["xEnumNames"] || schema["x-enumnames"] || schema["x-enum-varnames"];
+    return (
+      schema['x-enumNames'] ||
+      schema['xEnumNames'] ||
+      schema['x-enumnames'] ||
+      schema['x-enum-varnames']
+    );
   };
 
   getSchemaRefType = (schema) => {
     if (!this.isRefSchema(schema)) return null;
+    // const resolved = this.schemaWalker.findByRef(schema.$ref);
     return this.schemaComponentsMap.get(schema.$ref);
   };
 
   isPropertyRequired = (name, propertySchema, rootSchema) => {
-    if (propertySchema["x-omitempty"] === false) {
+    if (propertySchema['x-omitempty'] === false) {
       return true;
     }
 
@@ -62,7 +73,9 @@ class SchemaUtils {
   isNullMissingInType = (schema, type) => {
     const { nullable, type: schemaType } = schema || {};
     return (
-      (nullable || !!_.get(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) &&
+      (nullable ||
+        !!_.get(schema, 'x-nullable') ||
+        schemaType === this.config.Ts.Keyword.Null) &&
       _.isString(type) &&
       !type.includes(` ${this.config.Ts.Keyword.Null}`) &&
       !type.includes(`${this.config.Ts.Keyword.Null} `)
@@ -91,7 +104,7 @@ class SchemaUtils {
     if (_.keys(schema.properties).length) {
       return SCHEMA_TYPES.OBJECT;
     }
-    if (!!schema.items) {
+    if (schema.items) {
       return SCHEMA_TYPES.ARRAY;
     }
 
@@ -99,16 +112,21 @@ class SchemaUtils {
   };
 
   checkAndAddRequiredKeys = (schema, resultType) => {
-    if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
+    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 this.config.Ts.TypeWithGeneric(
+        this.config.Ts.CodeGenKeyword.UtilRequiredKeys,
+        [
+          resultType,
+          this.config.Ts.UnionType(
+            schema.$$requiredKeys.map(this.config.Ts.StringValue),
+          ),
+        ],
+      );
     }
 
     return resultType;
@@ -117,13 +135,20 @@ class SchemaUtils {
   makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
     if (!childSchema) return childSchema;
 
-    const required = _.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
+    const required = _.uniq([
+      ...this.getRequiredProperties(parentSchema),
+      ...this.getRequiredProperties(childSchema),
+    ]);
 
     const refData = this.getSchemaRefType(childSchema);
 
     if (refData) {
-      const refObjectProperties = _.keys((refData.rawTypeData && refData.rawTypeData.properties) || {});
-      const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
+      const refObjectProperties = _.keys(
+        (refData.rawTypeData && refData.rawTypeData.properties) || {},
+      );
+      const existedRequiredKeys = refObjectProperties.filter((key) =>
+        required.includes(key),
+      );
 
       if (!existedRequiredKeys.length) return childSchema;
 
@@ -133,12 +158,17 @@ class SchemaUtils {
       };
     } else if (childSchema.properties) {
       const childSchemaProperties = _.keys(childSchema.properties);
-      const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
+      const existedRequiredKeys = childSchemaProperties.filter((key) =>
+        required.includes(key),
+      );
 
       if (!existedRequiredKeys.length) return childSchema;
 
       return {
-        required: _.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
+        required: _.uniq([
+          ...this.getRequiredProperties(childSchema),
+          ...existedRequiredKeys,
+        ]),
         ...childSchema,
       };
     }
@@ -146,6 +176,33 @@ class SchemaUtils {
     return childSchema;
   };
 
+  filterSchemaContents = (contents, filterFn) => {
+    return _.uniq(_.filter(contents, (type) => filterFn(type)));
+  };
+
+  resolveTypeName = (
+    typeName,
+    { suffixes, resolver, prefixes, shouldReserve = true },
+  ) => {
+    if (resolver) {
+      return this.config.componentTypeNameResolver.resolve(null, (reserved) => {
+        return resolver(pascalCase(typeName), reserved);
+      });
+    } else {
+      return this.config.componentTypeNameResolver.resolve(
+        [
+          ...(prefixes || []).map((prefix) =>
+            pascalCase(`${prefix} ${typeName}`),
+          ),
+          ...(suffixes || []).map((suffix) =>
+            pascalCase(`${typeName} ${suffix}`),
+          ),
+        ],
+        shouldReserve,
+      );
+    }
+  };
+
   getComplexType = (schema) => {
     if (schema.oneOf) return SCHEMA_TYPES.COMPLEX_ONE_OF;
     if (schema.allOf) return SCHEMA_TYPES.COMPLEX_ALL_OF;
@@ -157,15 +214,26 @@ class SchemaUtils {
   };
 
   getInternalSchemaType = (schema) => {
-    if (!_.isEmpty(schema.enum) || !_.isEmpty(this.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;
-    if (schema.type === SCHEMA_TYPES.ARRAY) return SCHEMA_TYPES.ARRAY;
+    if (!_.isEmpty(schema.enum) || !_.isEmpty(this.getEnumNames(schema))) {
+      return SCHEMA_TYPES.ENUM;
+    }
+    if (schema.discriminator) {
+      return SCHEMA_TYPES.DISCRIMINATOR;
+    }
+    if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) {
+      return SCHEMA_TYPES.COMPLEX;
+    }
+    if (!_.isEmpty(schema.properties)) {
+      return SCHEMA_TYPES.OBJECT;
+    }
+    if (schema.type === SCHEMA_TYPES.ARRAY) {
+      return SCHEMA_TYPES.ARRAY;
+    }
 
     return SCHEMA_TYPES.PRIMITIVE;
   };
 
-  getSchemaType = async (schema) => {
+  getSchemaType = (schema) => {
     if (!schema) return this.config.Ts.Keyword.Any;
 
     const refTypeInfo = this.getSchemaRefType(schema);
@@ -173,7 +241,10 @@ class SchemaUtils {
     if (refTypeInfo) {
       return this.checkAndAddRequiredKeys(
         schema,
-        this.safeAddNullToType(schema, this.typeNameFormatter.format(refTypeInfo.typeName)),
+        this.safeAddNullToType(
+          schema,
+          this.typeNameFormatter.format(refTypeInfo.typeName),
+        ),
       );
     }
 
@@ -183,41 +254,35 @@ class SchemaUtils {
 
     let resultType;
 
-    /**
-     * @type {string | (() => Promise<string>)}
-     */
     const typeAlias =
       _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
-      _.get(this.config.primitiveTypes, [primitiveType, "$default"]) ||
+      _.get(this.config.primitiveTypes, [primitiveType, '$default']) ||
       this.config.primitiveTypes[primitiveType];
 
     if (_.isFunction(typeAlias)) {
-      resultType = await typeAlias(schema, this);
+      resultType = typeAlias(schema, this);
     } else {
       resultType = typeAlias || primitiveType;
     }
 
     if (!resultType) return this.config.Ts.Keyword.Any;
 
-    return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, resultType));
+    return this.checkAndAddRequiredKeys(
+      schema,
+      this.safeAddNullToType(schema, resultType),
+    );
   };
 
-  filterSchemaContents = (contents, filterFn) => {
-    return _.uniq(_.filter(contents, (type) => filterFn(type)));
-  };
+  buildTypeNameFromPath = (schemaPath) => {
+    schemaPath = _.uniq(_.compact(schemaPath));
 
-  resolveTypeName = (typeName, suffixes, resolver) => {
-    if (resolver) {
-      return this.config.componentTypeNameResolver.resolve((reserved) => {
-        const variant = resolver(pascalCase(typeName), reserved);
-        if (variant == null) return variant;
-        return pascalCase(variant);
-      });
-    } else {
-      return this.config.componentTypeNameResolver.resolve(
-        suffixes.map((suffix) => pascalCase(`${typeName} ${suffix}`)),
-      );
-    }
+    if (!schemaPath || !schemaPath[0]) return null;
+
+    return pascalCase(
+      camelCase(
+        _.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join('_'),
+      ),
+    );
   };
 }
 

package/src/schema-parser/util/enum-key-resolver.js

@@ -0,0 +1,26 @@
+const { NameResolver } = require('../../util/name-resolver');
+
+class EnumKeyResolver extends NameResolver {
+  counter = 1;
+  /**
+   * @param {CodeGenConfig} config;
+   * @param {Logger} logger;
+   * @param {string[]} reservedNames
+   */
+  constructor(config, logger, reservedNames) {
+    super(config, logger, reservedNames, (variants) => {
+      const generatedVariant =
+        (variants[0] && `${variants[0]}${this.counter++}`) ||
+        `${this.config.enumKeyResolverName}${this.counter++}`;
+      this.logger.debug(
+        'generated fallback type name for enum key - ',
+        generatedVariant,
+      );
+      return generatedVariant;
+    });
+  }
+}
+
+module.exports = {
+  EnumKeyResolver,
+};