swagger-typescript-api 10.0.1 → 10.0.2

package/src/render/utils/index.js

@@ -1,23 +1,31 @@
-const { classNameCase, formatDescription, internalCase } = require("../../common");
-const { getComponentByRef } = require("../../components");
-const { formatModelName } = require("../../modelNames");
-const { getInlineParseContent, getParseContent, parseSchema } = require("../../schema");
-const { formatters, inlineExtraFormatters } = require("../../typeFormatters");
-const { NameResolver } = require("../../utils/resolveName");
-
-module.exports = {
-  formatDescription,
-  internalCase,
-  classNameCase,
-  getInlineParseContent,
-  getParseContent,
-  getComponentByRef,
-  parseSchema,
-  formatters,
-  inlineExtraFormatters,
-  formatModelName,
-  fmtToJSDocLine: require("./fmtToJSDocLine"),
-  NameResolver: NameResolver,
-  _: require("lodash"),
-  require: require("./templateRequire").templateRequire,
-};
+const { classNameCase, formatDescription, internalCase } = require("../../common");
+const { getComponentByRef } = require("../../components");
+const { formatModelName } = require("../../modelNames");
+const {
+  getInlineParseContent,
+  getParseContent,
+  parseSchema,
+  checkAndAddNull,
+  isNeedToAddNull,
+} = require("../../schema");
+const { formatters, inlineExtraFormatters } = require("../../typeFormatters");
+const { NameResolver } = require("../../utils/resolveName");
+
+module.exports = {
+  formatDescription,
+  internalCase,
+  classNameCase,
+  getInlineParseContent,
+  getParseContent,
+  getComponentByRef,
+  parseSchema,
+  formatters,
+  checkAndAddNull,
+  isNeedToAddNull,
+  inlineExtraFormatters,
+  formatModelName,
+  fmtToJSDocLine: require("./fmtToJSDocLine"),
+  NameResolver: NameResolver,
+  _: require("lodash"),
+  require: require("./templateRequire").templateRequire,
+};

package/src/render/utils/templateRequire.js

@@ -1,17 +1,17 @@
-const _ = require("lodash");
-const path = require("path");
-const { config } = require("../../config");
-
-const templateRequire = (packageOrPath) => {
-  const isPath = _.startsWith(packageOrPath, "./") || _.startsWith(packageOrPath, "../");
-
-  if (isPath) {
-    return require(path.resolve(config.templates, packageOrPath));
-  }
-
-  return require(packageOrPath);
-};
-
-module.exports = {
-  templateRequire,
-};
+const _ = require("lodash");
+const path = require("path");
+const { config } = require("../../config");
+
+const templateRequire = (packageOrPath) => {
+  const isPath = _.startsWith(packageOrPath, "./") || _.startsWith(packageOrPath, "../");
+
+  if (isPath) {
+    return require(path.resolve(config.templates, packageOrPath));
+  }
+
+  return require(packageOrPath);
+};
+
+module.exports = {
+  templateRequire,
+};

package/src/routeNames.js

@@ -1,46 +1,46 @@
-const { config } = require("./config");
-const { logger } = require("./logger");
-const { renderTemplate } = require("./templates");
-
-const getRouteName = (routeInfo) => {
-  const { moduleName } = routeInfo;
-  const { routeNameDuplicatesMap, templatesToRender } = config;
-  const routeNameTemplate = templatesToRender.routeName;
-
-  const routeNameFromTemplate = renderTemplate(routeNameTemplate, {
-    routeInfo: routeInfo,
-    utils: require("./render/utils"),
-    config,
-  });
-
-  const routeName = config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
-
-  const duplicateIdentifier = `${moduleName}|${routeName}`;
-
-  if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
-    routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
-
-    logger.warn(
-      `Module "${moduleName}" already has method "${routeName}()"`,
-      `\nThis method has been renamed to "${
-        routeName + routeNameDuplicatesMap.get(duplicateIdentifier)
-      }()" to solve conflict names.`,
-    );
-  } else {
-    routeNameDuplicatesMap.set(duplicateIdentifier, 1);
-  }
-
-  const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
-
-  const routeNameInfo = {
-    usage: routeName + (duplicates > 1 ? duplicates : ""),
-    original: routeName,
-    duplicate: duplicates > 1,
-  };
-
-  return config.hooks.onCreateRouteName(routeNameInfo, routeInfo) || routeNameInfo;
-};
-
-module.exports = {
-  getRouteName,
-};
+const { config } = require("./config");
+const { logger } = require("./logger");
+const { renderTemplate } = require("./templates");
+
+const getRouteName = (routeInfo) => {
+  const { moduleName } = routeInfo;
+  const { routeNameDuplicatesMap, templatesToRender } = config;
+  const routeNameTemplate = templatesToRender.routeName;
+
+  const routeNameFromTemplate = renderTemplate(routeNameTemplate, {
+    routeInfo: routeInfo,
+    utils: require("./render/utils"),
+    config,
+  });
+
+  const routeName = config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
+
+  const duplicateIdentifier = `${moduleName}|${routeName}`;
+
+  if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
+    routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
+
+    logger.warn(
+      `Module "${moduleName}" already has method "${routeName}()"`,
+      `\nThis method has been renamed to "${
+        routeName + routeNameDuplicatesMap.get(duplicateIdentifier)
+      }()" to solve conflict names.`,
+    );
+  } else {
+    routeNameDuplicatesMap.set(duplicateIdentifier, 1);
+  }
+
+  const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
+
+  const routeNameInfo = {
+    usage: routeName + (duplicates > 1 ? duplicates : ""),
+    original: routeName,
+    duplicate: duplicates > 1,
+  };
+
+  return config.hooks.onCreateRouteName(routeNameInfo, routeInfo) || routeNameInfo;
+};
+
+module.exports = {
+  getRouteName,
+};

package/src/routes.js

@@ -520,7 +520,10 @@ const parseRoutes = ({ usageSchema, parsedSchemas, moduleNameIndex, moduleNameFi
             moduleNameFirstTag && firstTag
               ? _.camelCase(firstTag)
               : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
-          const hasSecurity = !!((globalSecurity && globalSecurity.length) || (security && security.length));
+          let hasSecurity = !!(globalSecurity && globalSecurity.length);
+          if (security) {
+            hasSecurity = security.length > 0;
+          }
 
           const routeParams = getRouteParams(routeInfo, pathParams);
 

package/src/schema.js

@@ -74,6 +74,23 @@ const getInternalSchemaType = (schema) => {
   return SCHEMA_TYPES.PRIMITIVE;
 };
 
+const isNeedToAddNull = (contract, value) => {
+  const { nullable, type } = contract || {};
+  return (
+    (nullable || !!_.get(contract, "x-nullable") || type === TS_KEYWORDS.NULL) &&
+    (!_.isString(value) || (!value.includes(` ${TS_KEYWORDS.NULL}`) && !value.includes(`${TS_KEYWORDS.NULL} `)))
+  );
+};
+
+const checkAndAddRequiredKeys = (schema, resultType) => {
+  if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
+    config.internalTemplateOptions.addUtilRequiredKeysType = true;
+    return `UtilRequiredKeys<${resultType}, ${schema.$$requiredKeys.map((k) => `"${k}"`).join(" | ")}>`;
+  }
+
+  return resultType;
+};
+
 const checkAndAddNull = (schema, value) => {
   const { nullable, type } = schema || {};
   return (nullable || !!_.get(schema, "x-nullable") || type === TS_KEYWORDS.NULL) &&
@@ -88,9 +105,9 @@ const isRef = (property) => {
   return !!(property && property["$ref"]);
 };
 
-const getRefType = (property) => {
-  const ref = property && property["$ref"];
-  return (ref && config.componentsMap[ref]) || null;
+const getRefType = (schema) => {
+  const ref = schema && schema["$ref"];
+  return config.componentsMap[ref] || null;
 };
 
 const getType = (schema) => {
@@ -99,11 +116,11 @@ const getType = (schema) => {
   const refTypeInfo = getRefType(schema);
 
   if (refTypeInfo) {
-    return checkAndAddNull(schema, formatModelName(refTypeInfo.typeName));
+    return checkAndAddRequiredKeys(schema, checkAndAddNull(schema, formatModelName(refTypeInfo.typeName)));
   }
 
   const primitiveType = getTypeAlias(schema);
-  return primitiveType ? checkAndAddNull(schema, primitiveType) : TS_KEYWORDS.ANY;
+  return primitiveType ? checkAndAddRequiredKeys(schema, checkAndAddNull(schema, primitiveType)) : TS_KEYWORDS.ANY;
 };
 
 const isRequired = (property, name, requiredProperties) => {
@@ -177,73 +194,76 @@ const getObjectTypeContent = (schema) => {
   return propertiesContent;
 };
 
-const complexTypeGetter = (schema) => getInlineParseContent(schema);
-const filterContents = (contents, types) => _.filter(contents, (type) => !_.includes(types, type));
-
-const makeAddRequiredToChildSchema = (parentSchema) => (childSchema) => {
-  let required = childSchema.required || [];
-  let properties = childSchema.properties || {};
-
-  // Inherit all the required fields from the parent schema that are defined
-  // either on the parent schema or on the child schema
-  // TODO: any that are defined at grandparents or higher are ignored
-  required = required.concat(
-    (parentSchema.required || []).filter(
-      (key) =>
-        !required.includes(key) && (_.keys(properties).includes(key) || _.keys(parentSchema.properties).includes(key)),
-    ),
-  );
+const filterContents = (contents, types) => _.uniq(_.filter(contents, (type) => !_.includes(types, type)));
 
-  // Identify properties that are required in the child schema, but
-  // defined only in the parent schema (TODO: this only works one level deep)
-  const parentPropertiesRequiredByChild = required.filter(
-    (key) => !_.keys(childSchema.properties).includes(key) && _.keys(parentSchema.properties).includes(key),
-  );
+const makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
+  if (!childSchema) return childSchema;
 
-  // Add such properties to the child so that they can be overriden and made required
-  properties = {
-    ...properties,
-    ...parentPropertiesRequiredByChild.reduce(
-      (additionalProperties, key) => ({
-        ...additionalProperties,
-        [key]: (parentSchema.properties || {})[key],
-      }),
-      {},
-    ),
-  };
-
-  return _.merge(
-    {
-      required: required,
-      properties: properties,
-    },
-    childSchema,
-  );
+  const required = _.uniq([...(parentSchema.required || []), ...(childSchema.required || [])]);
+
+  const refData = 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,
+    };
+  } 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;
 };
 
 const complexSchemaParsers = {
+  // T1 | T2
   [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
-    // T1 | T2
-    const combined = _.map(_.map(schema.oneOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
+    const combined = _.map(schema.oneOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
+    );
+    const filtered = filterContents(combined, [TS_KEYWORDS.ANY]);
 
-    return checkAndAddNull(schema, filterContents(combined, [TS_KEYWORDS.ANY]).join(" | "));
+    const type = filtered.join(" | ");
+
+    return checkAndAddNull(schema, type);
   },
+  // T1 & T2
   [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
-    // T1 & T2
-    const combined = _.map(_.map(schema.allOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
-    return checkAndAddNull(
-      schema,
-      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(" & "),
+    const combined = _.map(schema.allOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
     );
+    const filtered = filterContents(combined, [...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
+
+    const type = filtered.join(TS_KEYWORDS.TYPE_AND_OPERATOR);
+
+    return checkAndAddNull(schema, type);
   },
+  // T1 | T2 | (T1 & T2)
   [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
-    // T1 | T2 | (T1 & T2)
-    const combined = _.map(_.map(schema.anyOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
-    const nonEmptyTypesCombined = filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
-    return checkAndAddNull(
-      schema,
-      `${combined.join(" | ")}` + (nonEmptyTypesCombined.length > 1 ? ` | (${nonEmptyTypesCombined.join(" & ")})` : ""),
+    const combined = _.map(schema.anyOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
     );
+    const filtered = filterContents(combined, [...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
+
+    const type = _.compact([
+      ...filtered,
+      filtered.length > 1 && `(${filtered.join(TS_KEYWORDS.TYPE_AND_OPERATOR)})`,
+    ]).join(TS_KEYWORDS.TYPE_OR_OPERATOR);
+
+    return checkAndAddNull(schema, type);
   },
   // TODO
   [SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
@@ -357,15 +377,17 @@ const schemaParsers = {
         schema.description || _.compact(_.map(schema[complexType], "description"))[0] || "",
       ),
       content:
-        _.compact([
-          complexSchemaContent && `(${complexSchemaContent})`,
-          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT && getInlineParseContent(simpleSchema),
-        ]).join(" & ") || TS_KEYWORDS.ANY,
+        _.uniq(
+          _.compact([
+            complexSchemaContent && `(${complexSchemaContent})`,
+            getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT && `(${getInlineParseContent(simpleSchema)})`,
+          ]),
+        ).join(" & ") || TS_KEYWORDS.ANY,
     });
   },
   [SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
     let contentType = null;
-    const { additionalProperties, type, description } = schema || {};
+    const { additionalProperties, type, description, $$requiredKeys } = schema || {};
 
     if (type === TS_KEYWORDS.OBJECT && additionalProperties) {
       const fieldType = _.isObject(additionalProperties)
@@ -444,6 +466,7 @@ module.exports = {
   parseSchemas,
   getInlineParseContent,
   getParseContent,
+  isNeedToAddNull,
   getType,
   getRefType,
   SCHEMA_TYPES,

package/src/swagger.js

@@ -25,7 +25,10 @@ const getSwaggerFile = (pathToSwagger, urlToSwagger, disableStrictSSL, disablePr
     } else {
       logger.log(`try to get swagger by URL "${urlToSwagger}"`);
       // setup options for Axios
-      const axiosOptions = {};
+      const axiosOptions = {
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+      };
       //
       if (disableStrictSSL) {
         axiosOptions.httpsAgent = new https.Agent({