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

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

@@ -0,0 +1,79 @@
+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");
+const { SchemaParser } = require("./schema-parser");
+
+class SchemaProcessor {
+  /**
+   * @type {CodeGenConfig}
+   */
+  config;
+
+  /**
+   * @type {SchemaComponentsMap}
+   */
+  schemaComponentsMap;
+  /**
+   * @type {TypeNameFormatter}
+   */
+  typeNameFormatter;
+  /**
+   * @type {SchemaFormatters}
+   */
+  schemaFormatters;
+
+  /**
+   * @type {SchemaUtils}
+   */
+  schemaUtils;
+
+  /**
+   * @type {((schema, typeName) => SchemaParser)}
+   */
+  createSchemaParser;
+
+  constructor(config, logger, templates, schemaComponentsMap, typeNameFormatter) {
+    this.config = config;
+    this.schemaComponentsMap = schemaComponentsMap;
+    this.typeNameFormatter = typeNameFormatter;
+    this.schemaFormatters = new SchemaFormatters(config, logger, this, templates);
+    this.schemaUtils = new SchemaUtils(config, schemaComponentsMap, typeNameFormatter);
+    this.createSchemaParser = SchemaParser.create.bind(
+      null,
+      config,
+      schemaComponentsMap,
+      typeNameFormatter,
+      this.schemaFormatters,
+      this.schemaUtils,
+    );
+  }
+
+  /**
+   *
+   * @param schema {any}
+   * @param typeName {null | string}
+   * @return {Promise<Record<string, any>>}
+   */
+  parseSchema = async (schema, typeName = null) => {
+    const schemaParser = this.createSchemaParser(schema, typeName);
+    return await schemaParser.parse();
+  };
+
+  getInlineParseContent = async (schema, typeName) => {
+    const parser = this.createSchemaParser(schema, typeName);
+    return await parser.getInlineContent();
+  };
+
+  getParseContent = async (schema, typeName) => {
+    const parser = this.createSchemaParser(schema, typeName);
+    return await parser.getContent();
+  };
+}
+
+module.exports = {
+  SchemaProcessor,
+};

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

@@ -25,7 +25,7 @@ class SchemaRoutes {
    */
   config;
   /**
-   * @type {SchemaParser}
+   * @type {SchemaProcessor}
    */
   schemaParser;
   /**
@@ -33,7 +33,7 @@ class SchemaRoutes {
    */
   schemaUtils;
   /**
-   * @type {TypeName}
+   * @type {TypeNameFormatter}
    */
   typeName;
   /**
@@ -64,10 +64,12 @@ class SchemaRoutes {
     this.schemaComponentMap = schemaComponentMap;
     this.logger = logger;
     this.templates = templates;
+  }
 
+  async init() {
     this.FORM_DATA_TYPES = _.uniq([
-      this.schemaParser.getSchemaType({ type: "string", format: "file" }),
-      this.schemaParser.getSchemaType({ type: "string", format: "binary" }),
+      await this.schemaUtils.getSchemaType({ type: "string", format: "file" }),
+      await this.schemaUtils.getSchemaType({ type: "string", format: "binary" }),
     ]);
   }
 
@@ -308,13 +310,13 @@ class SchemaRoutes {
     return null;
   };
 
-  getTypeFromRequestInfo = ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
+  getTypeFromRequestInfo = async ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
     // TODO: make more flexible pick schema without content type
     const schema = this.getSchemaFromRequestType(requestInfo);
     const refTypeInfo = this.schemaParser.schemaUtils.getSchemaRefType(requestInfo);
 
     if (schema) {
-      const content = this.schemaParser.getInlineParseContent(schema, typeName);
+      const content = await this.schemaParser.getInlineParseContent(schema, typeName);
       const foundedSchemaByName = _.find(
         parsedSchemas,
         (parsedSchema) => this.typeName.format(parsedSchema.name) === content,
@@ -341,54 +343,56 @@ class SchemaRoutes {
           return this.typeName.format(refTypeInfo.typeName);
         case "responses":
         case "requestBodies":
-          return this.schemaParser.getInlineParseContent(
+          return await this.schemaParser.getInlineParseContent(
             this.getSchemaFromRequestType(refTypeInfo.rawTypeData),
             refTypeInfo.typeName || null,
           );
         default:
-          return this.schemaParser.getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null);
+          return await this.schemaParser.getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null);
       }
     }
 
     return defaultType || this.config.Ts.Keyword.Any;
   };
 
-  getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) =>
-    _.reduce(
-      requestInfos,
-      (acc, requestInfo, status) => {
-        const contentTypes = this.getContentTypes([requestInfo]);
-
-        return [
-          ...acc,
-          {
-            ...(requestInfo || {}),
-            contentTypes: contentTypes,
-            contentKind: this.getContentKind(contentTypes),
-            type: this.schemaParser.schemaUtils.safeAddNullToType(
-              requestInfo,
-              this.getTypeFromRequestInfo({
-                requestInfo,
-                parsedSchemas,
-                operationId,
-                defaultType,
-              }),
-            ),
-            description: this.schemaParser.schemaFormatters.formatDescription(requestInfo.description || "", true),
-            status: _.isNaN(+status) ? status : +status,
-            isSuccess: this.isSuccessStatus(status),
-          },
-        ];
-      },
-      [],
-    );
+  getRequestInfoTypes = async ({ requestInfos, parsedSchemas, operationId, defaultType }) => {
+    const requestInfoTypes = [];
+
+    const statuses = _.entries(requestInfos);
+
+    for await (const [status, requestInfo] of statuses) {
+      const contentTypes = this.getContentTypes([requestInfo]);
+
+      const requestInfoType = {
+        ...(requestInfo || {}),
+        contentTypes: contentTypes,
+        contentKind: this.getContentKind(contentTypes),
+        type: this.schemaParser.schemaUtils.safeAddNullToType(
+          requestInfo,
+          await this.getTypeFromRequestInfo({
+            requestInfo,
+            parsedSchemas,
+            operationId,
+            defaultType,
+          }),
+        ),
+        description: this.schemaParser.schemaFormatters.formatDescription(requestInfo.description || "", true),
+        status: _.isNaN(+status) ? status : +status,
+        isSuccess: this.isSuccessStatus(status),
+      };
+
+      requestInfoTypes.push(requestInfoType);
+    }
 
-  getResponseBodyInfo = (routeInfo, routeParams, parsedSchemas) => {
+    return requestInfoTypes;
+  };
+
+  getResponseBodyInfo = async (routeInfo, routeParams, parsedSchemas) => {
     const { produces, operationId, responses } = routeInfo;
 
     const contentTypes = this.getContentTypes(responses, [...(produces || []), routeInfo["x-accepts"]]);
 
-    const responseInfos = this.getRequestInfoTypes({
+    const responseInfos = await this.getRequestInfoTypes({
       requestInfos: responses,
       parsedSchemas,
       operationId,
@@ -400,14 +404,16 @@ class SchemaRoutes {
       (response) => !response.isSuccess && response.type !== this.config.Ts.Keyword.Any,
     );
 
-    const handleResponseHeaders = (src) => {
+    const handleResponseHeaders = async (src) => {
       if (!src) {
         return "headers: {},";
       }
       const headerTypes = Object.fromEntries(
-        Object.entries(src).map(([k, v]) => {
-          return [k, this.schemaParser.getSchemaType(v)];
-        }),
+        await Promise.all(
+          Object.entries(src).map(async ([k, v]) => {
+            return [k, await this.schemaUtils.getSchemaType(v)];
+          }),
+        ),
       );
       const r = `headers: { ${Object.entries(headerTypes)
         .map(([k, v]) => `"${k}": ${v}`)
@@ -429,11 +435,13 @@ class SchemaRoutes {
       full: {
         types:
           this.config.Ts.UnionType(
-            responseInfos.map(
-              (response) => `{
+            await Promise.all(
+              responseInfos.map(
+                async (response) => `{
       data: ${response.type}, status: ${response.status}, statusCode: ${response.status}, statusText: "${
-                response.description
-              }", ${handleResponseHeaders(response.headers)} config: {} }`,
+                  response.description
+                }", ${await handleResponseHeaders(response.headers)} config: {} }`,
+              ),
             ),
           ) || this.config.Ts.Keyword.Any,
       },
@@ -464,7 +472,7 @@ class SchemaRoutes {
     );
   };
 
-  getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) => {
+  getRequestBodyInfo = async (routeInfo, routeParams, parsedSchemas, routeName) => {
     const { requestBody, consumes, requestBodyName, operationId } = routeInfo;
     let schema = null;
     let type = null;
@@ -485,15 +493,15 @@ class SchemaRoutes {
     if (routeParams.formData.length) {
       contentKind = CONTENT_KIND.FORM_DATA;
       schema = this.convertRouteParamsIntoObject(routeParams.formData);
-      type = this.schemaParser.getInlineParseContent(schema, typeName);
+      type = await this.schemaParser.getInlineParseContent(schema, typeName);
     } else if (contentKind === CONTENT_KIND.FORM_DATA) {
       schema = this.getSchemaFromRequestType(requestBody);
-      type = this.schemaParser.getInlineParseContent(schema, typeName);
+      type = await this.schemaParser.getInlineParseContent(schema, typeName);
     } else if (requestBody) {
       schema = this.getSchemaFromRequestType(requestBody);
       type = this.schemaParser.schemaUtils.safeAddNullToType(
         requestBody,
-        this.getTypeFromRequestInfo({
+        await this.getTypeFromRequestInfo({
           requestInfo: requestBody,
           parsedSchemas,
           operationId,
@@ -511,7 +519,7 @@ class SchemaRoutes {
 
     if (schema && !schema.$ref && this.config.extractRequestBody) {
       schema = this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
-      type = this.schemaParser.getInlineParseContent(schema);
+      type = await this.schemaParser.getInlineParseContent(schema);
     }
 
     return {
@@ -588,7 +596,7 @@ class SchemaRoutes {
     return schema;
   };
 
-  extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
+  extractResponseBodyIfItNeeded = async (routeInfo, responseBodyInfo, routeName) => {
     if (responseBodyInfo.responses.length && responseBodyInfo.success && responseBodyInfo.success.schema) {
       const typeName = this.schemaUtils.resolveTypeName(
         routeName.usage,
@@ -603,7 +611,7 @@ class SchemaRoutes {
       if (successResponse.schema && !successResponse.schema.$ref) {
         const schema = this.getSchemaFromRequestType(successResponse.schema);
         successResponse.schema = this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
-        successResponse.type = this.schemaParser.getInlineParseContent(successResponse.schema);
+        successResponse.type = await this.schemaParser.getInlineParseContent(successResponse.schema);
 
         if (idx > -1) {
           _.assign(responseBodyInfo.responses[idx], {
@@ -615,7 +623,7 @@ class SchemaRoutes {
     }
   };
 
-  extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
+  extractResponseErrorIfItNeeded = async (routeInfo, responseBodyInfo, routeName) => {
     if (responseBodyInfo.responses.length && responseBodyInfo.error.schemas && responseBodyInfo.error.schemas.length) {
       const typeName = this.schemaUtils.resolveTypeName(
         routeName.usage,
@@ -627,7 +635,7 @@ class SchemaRoutes {
 
       if (!errorSchemas.length) return;
 
-      const schema = this.schemaParser.parseSchema({
+      const schema = await this.schemaParser.parseSchema({
         oneOf: errorSchemas,
         title: errorSchemas
           .map((schema) => schema.title)
@@ -644,12 +652,12 @@ class SchemaRoutes {
     }
   };
 
-  getRouteName = (rawRouteInfo) => {
+  getRouteName = async (rawRouteInfo) => {
     const { moduleName } = rawRouteInfo;
     const { routeNameDuplicatesMap, templatesToRender } = this.config;
     const routeNameTemplate = templatesToRender.routeName;
 
-    const routeNameFromTemplate = this.templates.renderTemplate(routeNameTemplate, {
+    const routeNameFromTemplate = await this.templates.renderTemplate(routeNameTemplate, {
       routeInfo: rawRouteInfo,
     });
 
@@ -681,7 +689,7 @@ class SchemaRoutes {
     return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
   };
 
-  parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
+  parseRouteInfo = async (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
     const { security: globalSecurity } = usageSchema;
     const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } = this.config;
     const {
@@ -717,15 +725,17 @@ class SchemaRoutes {
 
     const routeParams = this.getRouteParams(routeInfo, pathParamsFromRouteName, queryParamsFromRouteName);
 
-    const pathArgs = routeParams.path.map((pathArgSchema) => ({
-      name: pathArgSchema.name,
-      optional: !pathArgSchema.required,
-      type: this.schemaParser.getInlineParseContent(pathArgSchema.schema),
-      description: pathArgSchema.description,
-    }));
+    const pathArgs = await Promise.all(
+      routeParams.path.map(async (pathArgSchema) => ({
+        name: pathArgSchema.name,
+        optional: !pathArgSchema.required,
+        type: await this.schemaParser.getInlineParseContent(pathArgSchema.schema),
+        description: pathArgSchema.description,
+      })),
+    );
     const pathArgsNames = pathArgs.map((arg) => arg.name);
 
-    const responseBodyInfo = this.getResponseBodyInfo(routeInfo, routeParams, parsedSchemas);
+    const responseBodyInfo = await this.getResponseBodyInfo(routeInfo, routeParams, parsedSchemas);
 
     const rawRouteInfo = {
       ...otherInfo,
@@ -748,9 +758,9 @@ class SchemaRoutes {
     const pathObjectSchema = this.convertRouteParamsIntoObject(routeParams.path);
     const headersObjectSchema = this.convertRouteParamsIntoObject(routeParams.header);
 
-    const routeName = this.getRouteName(rawRouteInfo);
+    const routeName = await this.getRouteName(rawRouteInfo);
 
-    const requestBodyInfo = this.getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
+    const requestBodyInfo = await this.getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
 
     const requestParamsSchema = this.createRequestParamsSchema({
       queryParams: routeParams.query,
@@ -761,15 +771,19 @@ class SchemaRoutes {
     });
 
     if (this.config.extractResponseBody) {
-      this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeName);
+      await this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeName);
     }
     if (this.config.extractResponseError) {
-      this.extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeName);
+      await this.extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeName);
     }
 
-    const queryType = routeParams.query.length ? this.schemaParser.getInlineParseContent(queryObjectSchema) : null;
-    const pathType = routeParams.path.length ? this.schemaParser.getInlineParseContent(pathObjectSchema) : null;
-    const headersType = routeParams.header.length ? this.schemaParser.getInlineParseContent(headersObjectSchema) : null;
+    const queryType = routeParams.query.length
+      ? await this.schemaParser.getInlineParseContent(queryObjectSchema)
+      : null;
+    const pathType = routeParams.path.length ? await this.schemaParser.getInlineParseContent(pathObjectSchema) : null;
+    const headersType = routeParams.header.length
+      ? await this.schemaParser.getInlineParseContent(headersObjectSchema)
+      : null;
 
     const nameResolver = new SpecificArgNameResolver(this.logger, pathArgsNames);
 
@@ -777,7 +791,7 @@ class SchemaRoutes {
       query: queryType
         ? {
             name: nameResolver.resolve(RESERVED_QUERY_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(queryObjectSchema).allFieldsAreOptional,
+            optional: (await this.schemaParser.parseSchema(queryObjectSchema)).allFieldsAreOptional,
             type: queryType,
           }
         : void 0,
@@ -791,14 +805,14 @@ class SchemaRoutes {
       pathParams: pathType
         ? {
             name: nameResolver.resolve(RESERVED_PATH_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(pathObjectSchema).allFieldsAreOptional,
+            optional: (await this.schemaParser.parseSchema(pathObjectSchema)).allFieldsAreOptional,
             type: pathType,
           }
         : void 0,
       headers: headersType
         ? {
             name: nameResolver.resolve(RESERVED_HEADER_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(headersObjectSchema).allFieldsAreOptional,
+            optional: (await this.schemaParser.parseSchema(headersObjectSchema)).allFieldsAreOptional,
             type: headersType,
           }
         : void 0,
@@ -843,16 +857,16 @@ class SchemaRoutes {
     };
   };
 
-  attachSchema = ({ usageSchema, parsedSchemas }) => {
+  attachSchema = async ({ usageSchema, parsedSchemas }) => {
     this.config.routeNameDuplicatesMap.clear();
 
     const pathsEntries = _.entries(usageSchema.paths);
 
-    _.forEach(pathsEntries, ([rawRouteName, routeInfoByMethodsMap]) => {
+    for await (const [rawRouteName, routeInfoByMethodsMap] of pathsEntries) {
       const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
 
-      _.forEach(routeInfosMap, (routeInfo, method) => {
-        const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
+      for await (const [method, routeInfo] of _.entries(routeInfosMap)) {
+        const parsedRouteInfo = await this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
         const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
         const route = processedRouteInfo || parsedRouteInfo;
 
@@ -867,8 +881,8 @@ class SchemaRoutes {
         }
 
         this.routes.push(route);
-      });
-    });
+      }
+    }
   };
 
   getGroupedRoutes = () => {

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

@@ -12,10 +12,15 @@ class SchemaUtils {
    * @type {SchemaComponentsMap}
    */
   schemaComponentsMap;
+  /**
+   * @type {TypeNameFormatter}
+   */
+  typeNameFormatter;
 
-  constructor(config, schemaComponentsMap) {
+  constructor(config, schemaComponentsMap, typeNameFormatter) {
     this.config = config;
     this.schemaComponentsMap = schemaComponentsMap;
+    this.typeNameFormatter = typeNameFormatter;
   }
 
   getRequiredProperties = (schema) => {
@@ -141,6 +146,62 @@ class SchemaUtils {
     return childSchema;
   };
 
+  getComplexType = (schema) => {
+    if (schema.oneOf) return SCHEMA_TYPES.COMPLEX_ONE_OF;
+    if (schema.allOf) return SCHEMA_TYPES.COMPLEX_ALL_OF;
+    if (schema.anyOf) return SCHEMA_TYPES.COMPLEX_ANY_OF;
+    // TODO :(
+    if (schema.not) return SCHEMA_TYPES.COMPLEX_NOT;
+
+    return SCHEMA_TYPES.COMPLEX_UNKNOWN;
+  };
+
+  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;
+
+    return SCHEMA_TYPES.PRIMITIVE;
+  };
+
+  getSchemaType = async (schema) => {
+    if (!schema) return this.config.Ts.Keyword.Any;
+
+    const refTypeInfo = this.getSchemaRefType(schema);
+
+    if (refTypeInfo) {
+      return this.checkAndAddRequiredKeys(
+        schema,
+        this.safeAddNullToType(schema, this.typeNameFormatter.format(refTypeInfo.typeName)),
+      );
+    }
+
+    const primitiveType = this.getSchemaPrimitiveType(schema);
+
+    if (primitiveType == null) return this.config.Ts.Keyword.Any;
+
+    let resultType;
+
+    /**
+     * @type {string | (() => Promise<string>)}
+     */
+    const typeAlias =
+      _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
+      _.get(this.config.primitiveTypes, [primitiveType, "$default"]) ||
+      this.config.primitiveTypes[primitiveType];
+
+    if (_.isFunction(typeAlias)) {
+      resultType = await typeAlias(schema, this);
+    } else {
+      resultType = typeAlias || primitiveType;
+    }
+
+    if (!resultType) return this.config.Ts.Keyword.Any;
+
+    return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, resultType));
+  };
+
   filterSchemaContents = (contents, filterFn) => {
     return _.uniq(_.filter(contents, (type) => filterFn(type)));
   };

package/src/templates.js

@@ -152,23 +152,28 @@ class Templates {
     return "";
   };
 
-  renderTemplate = (template, configuration, options) => {
+  renderTemplate = async (template, configuration, options) => {
     if (!template) return "";
 
-    return Eta.render(
-      template,
-      {
-        ...this.getRenderTemplateData(),
-        ...configuration,
-      },
-      {
-        async: false,
-        ...(options || {}),
-        includeFile: (path, configuration, options) => {
-          return this.renderTemplate(this.getTemplateContent(path), configuration, options);
+    try {
+      return await Eta.renderAsync(
+        template,
+        {
+          ...this.getRenderTemplateData(),
+          ...configuration,
         },
-      },
-    );
+        {
+          async: true,
+          ...(options || {}),
+          includeFile: async (path, configuration, options) => {
+            return await this.renderTemplate(this.getTemplateContent(path), configuration, options);
+          },
+        },
+      );
+    } catch (e) {
+      console.error("problem in this templates\n", template);
+      throw e;
+    }
   };
 }
 

package/src/{type-name.js → type-name-formatter.js}

@@ -4,7 +4,7 @@ const _ = require("lodash");
  * @typedef {"enum-key" | "type-name"} FormattingSchemaType
  */
 
-class TypeName {
+class TypeNameFormatter {
   /** @type {Map<string, string>} */
   formattedModelNamesMap = new Map();
 
@@ -94,5 +94,5 @@ class TypeName {
 }
 
 module.exports = {
-  TypeName,
+  TypeNameFormatter,
 };

package/src/util/request.js

@@ -1,3 +1,4 @@
+const _ = require("lodash");
 const https = require("https");
 const fetch = require("node-fetch-h2");
 
@@ -18,7 +19,7 @@ class Request {
 
   /**
    *
-   * @param url
+   * @param url {string}
    * @param disableStrictSSL
    * @param authToken
    * @param options {Partial<import("node-fetch").RequestInit>}
@@ -28,11 +29,9 @@ class Request {
     /**
      * @type {Partial<import("node-fetch").RequestInit>}
      */
-    const requestOptions = {
-      ...(this.config.requestOptions || {}),
-    };
+    const requestOptions = {};
 
-    if (disableStrictSSL) {
+    if (disableStrictSSL && !_.startsWith(url, "http://")) {
       requestOptions.agent = new https.Agent({
         rejectUnauthorized: false,
       });
@@ -43,7 +42,7 @@ class Request {
       };
     }
 
-    Object.assign(requestOptions, options);
+    _.merge(requestOptions, options, this.config.requestOptions);
 
     try {
       const response = await fetch(url, requestOptions);

package/templates/base/data-contracts.ejs

@@ -2,7 +2,6 @@
 const { modelTypes, utils, config } = it;
 const { formatDescription, require, _, Ts } = utils;
 
-
 const dataContractTemplates = {
   enum: (contract) => {
     return `enum ${contract.name} {\r\n${contract.content} \r\n }`;
@@ -20,9 +19,9 @@ const dataContractTemplates = {
 type <%~ config.Ts.CodeGenKeyword.UtilRequiredKeys %><T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
 <% } %>
 
-<% modelTypes.forEach((contract) => { %>
-  <%~ includeFile('@base/data-contract-jsdoc.ejs', { ...it, data: { ...contract, ...contract.typeData } }) %>
-  export <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
+<% for await (const contract of modelTypes) { %>
 
+  <%~ await includeFile('@base/data-contract-jsdoc.ejs', { ...it, data: { ...contract, ...contract.typeData } }) %>
+  export <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
 
-<% }) %>
+<% } %>

package/templates/base/http-client.ejs

@@ -1,3 +1,3 @@
 <% const { config } = it; %>
 <% /* https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/http-clients/ */ %>
-<%~ includeFile(`@base/http-clients/${config.httpClientType}-http-client`, it) %>
+<%~ await includeFile(`@base/http-clients/${config.httpClientType}-http-client`, it) %>