swagger-typescript-api 11.0.0--beta-1 → 11.0.0--beta-2

package/index.js

@@ -202,55 +202,60 @@ const program = cli({
 const main = async () => {
   const { command, options } = await program.execute({ args: process.argv });
 
-  switch (command) {
-    case null: {
-      await generateApi({
-        name: options.name,
-        url: options.path,
-        generateRouteTypes: options.routeTypes,
-        generateClient: !!(options.axios || options.client),
-        httpClientType: options.axios ? HTTP_CLIENT.AXIOS : HTTP_CLIENT.FETCH,
-        defaultResponseAsSuccess: options.defaultAsSuccess,
-        defaultResponseType: options.defaultResponse,
-        unwrapResponseData: options.unwrapResponseData,
-        disableThrowOnError: options.disableThrowOnError,
-        sortTypes: options.sortTypes,
-        generateUnionEnums: options.unionEnums,
-        addReadonly: options.addReadonly,
-        generateResponses: options.responses,
-        extractRequestParams: !!options.extractRequestParams,
-        extractRequestBody: !!options.extractRequestBody,
-        extractResponseBody: !!options.extractResponseBody,
-        extractResponseError: !!options.extractResponseError,
-        input: resolve(process.cwd(), options.path),
-        output: resolve(process.cwd(), options.output || "."),
-        templates: options.templates,
-        modular: !!options.modular,
-        toJS: !!options.js,
-        enumNamesAsValues: options.enumNamesAsValues,
-        moduleNameIndex: +(options.moduleNameIndex || 0),
-        moduleNameFirstTag: options.moduleNameFirstTag,
-        disableStrictSSL: !!options.disableStrictSSL,
-        disableProxy: !!options.disableProxy,
-        singleHttpClient: !!options.singleHttpClient,
-        cleanOutput: !!options.cleanOutput,
-        silent: !!options.silent,
-        typePrefix: options.typePrefix,
-        typeSuffix: options.typeSuffix,
-        patch: !!options.patch,
-        apiClassName: options.apiClassName,
-        debug: options.debug,
-        anotherArrayType: options.anotherArrayType,
-      });
-      break;
-    }
-    case "generate-templates": {
-      console.info("todo");
-      break;
-    }
-    default: {
-      break;
+  try {
+    switch (command) {
+      case null: {
+        await generateApi({
+          name: options.name,
+          url: options.path,
+          generateRouteTypes: options.routeTypes,
+          generateClient: !!(options.axios || options.client),
+          httpClientType: options.axios ? HTTP_CLIENT.AXIOS : HTTP_CLIENT.FETCH,
+          defaultResponseAsSuccess: options.defaultAsSuccess,
+          defaultResponseType: options.defaultResponse,
+          unwrapResponseData: options.unwrapResponseData,
+          disableThrowOnError: options.disableThrowOnError,
+          sortTypes: options.sortTypes,
+          generateUnionEnums: options.unionEnums,
+          addReadonly: options.addReadonly,
+          generateResponses: options.responses,
+          extractRequestParams: !!options.extractRequestParams,
+          extractRequestBody: !!options.extractRequestBody,
+          extractResponseBody: !!options.extractResponseBody,
+          extractResponseError: !!options.extractResponseError,
+          input: resolve(process.cwd(), options.path),
+          output: resolve(process.cwd(), options.output || "."),
+          templates: options.templates,
+          modular: !!options.modular,
+          toJS: !!options.js,
+          enumNamesAsValues: options.enumNamesAsValues,
+          moduleNameIndex: +(options.moduleNameIndex || 0),
+          moduleNameFirstTag: options.moduleNameFirstTag,
+          disableStrictSSL: !!options.disableStrictSSL,
+          disableProxy: !!options.disableProxy,
+          singleHttpClient: !!options.singleHttpClient,
+          cleanOutput: !!options.cleanOutput,
+          silent: !!options.silent,
+          typePrefix: options.typePrefix,
+          typeSuffix: options.typeSuffix,
+          patch: !!options.patch,
+          apiClassName: options.apiClassName,
+          debug: options.debug,
+          anotherArrayType: options.anotherArrayType,
+        });
+        break;
+      }
+      case "generate-templates": {
+        console.info("todo");
+        break;
+      }
+      default: {
+        break;
+      }
     }
+  } catch (e) {
+    console.error(e);
+    process.exit(1);
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-typescript-api",
-  "version": "11.0.0--beta-1",
+  "version": "11.0.0--beta-2",
   "description": "Generate typescript/javascript api from swagger schema",
   "scripts": {
     "cli:json": "node index.js -r -d -p ./swagger-test-cli.json -n swagger-test-cli.ts",

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

@@ -529,13 +529,8 @@ class SchemaRoutes {
     return schema;
   };
 
-  extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
-    if (
-      this.config.extractResponseBody &&
-      responseBodyInfo.responses.length &&
-      responseBodyInfo.success &&
-      responseBodyInfo.success.schema
-    ) {
+  extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
+    if (responseBodyInfo.responses.length && responseBodyInfo.success && responseBodyInfo.success.schema) {
       const typeName = this.config.componentTypeNameResolver.resolve([
         pascalCase(`${routeName.usage} Data`),
         pascalCase(`${routeName.usage} Result`),
@@ -552,19 +547,14 @@ class SchemaRoutes {
         successResponse.type = this.schemaParser.getInlineParseContent(successResponse.schema);
 
         if (idx > -1) {
-          responseBodyInfo.responses[idx] = successResponse.schema;
+          _.assign(responseBodyInfo.responses[idx], successResponse.schema);
         }
       }
     }
   };
 
-  extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
-    if (
-      this.config.extractResponseError &&
-      responseBodyInfo.responses.length &&
-      responseBodyInfo.error.schemas &&
-      responseBodyInfo.error.schemas.length
-    ) {
+  extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
+    if (responseBodyInfo.responses.length && responseBodyInfo.error.schemas && responseBodyInfo.error.schemas.length) {
       const typeName = this.config.componentTypeNameResolver.resolve([
         pascalCase(`${routeName.usage} Error`),
         pascalCase(`${routeName.usage} Fail`),
@@ -595,16 +585,16 @@ class SchemaRoutes {
     }
   };
 
-  getRouteName = (routeInfo) => {
-    const { moduleName } = routeInfo;
+  getRouteName = (rawRouteInfo) => {
+    const { moduleName } = rawRouteInfo;
     const { routeNameDuplicatesMap, templatesToRender } = this.config;
     const routeNameTemplate = templatesToRender.routeName;
 
     const routeNameFromTemplate = this.templates.renderTemplate(routeNameTemplate, {
-      routeInfo: routeInfo,
+      routeInfo: rawRouteInfo,
     });
 
-    const routeName = this.config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
+    const routeName = this.config.hooks.onFormatRouteName(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
 
     const duplicateIdentifier = `${moduleName}|${routeName}`;
 
@@ -629,7 +619,7 @@ class SchemaRoutes {
       duplicate: duplicates > 1,
     };
 
-    return this.config.hooks.onCreateRouteName(routeNameInfo, routeInfo) || routeNameInfo;
+    return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
   };
 
   parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
@@ -675,6 +665,7 @@ class SchemaRoutes {
     const responseBodyInfo = this.getResponseBodyInfo(routeInfo, routeParams, parsedSchemas);
 
     const rawRouteInfo = {
+      ...otherInfo,
       pathArgs,
       operationId,
       method,
@@ -688,7 +679,6 @@ class SchemaRoutes {
       produces,
       requestBody,
       consumes,
-      ...otherInfo,
     };
 
     const queryObjectSchema = this.convertRouteParamsIntoObject(routeParams.query);
@@ -707,8 +697,12 @@ class SchemaRoutes {
       routeName,
     });
 
-    this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
-    this.extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
+    if (this.config.extractResponseBody) {
+      this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeName);
+    }
+    if (this.config.extractResponseError) {
+      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;
@@ -747,29 +741,6 @@ class SchemaRoutes {
         : void 0,
     };
 
-    let routeArgs = _.compact([...pathArgs, specificArgs.query, specificArgs.body]);
-
-    if (routeArgs.some((pathArg) => pathArg.optional)) {
-      const { optionalArgs, requiredArgs } = _.reduce(
-        [...routeArgs],
-        (acc, pathArg) => {
-          if (pathArg.optional) {
-            acc.optionalArgs.push(pathArg);
-          } else {
-            acc.requiredArgs.push(pathArg);
-          }
-
-          return acc;
-        },
-        {
-          optionalArgs: [],
-          requiredArgs: [],
-        },
-      );
-
-      routeArgs = [...requiredArgs, ...optionalArgs];
-    }
-
     return {
       id: routeId,
       namespace: _.replace(moduleName, /^(\d)/, "v$1"),
@@ -819,10 +790,8 @@ class SchemaRoutes {
 
       _.forEach(routeInfosMap, (routeInfo, method) => {
         const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
-
-        const usageRouteData = this.config.hooks.onCreateRoute(parsedRouteInfo);
-
-        const route = usageRouteData || parsedRouteInfo;
+        const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
+        const route = processedRouteInfo || parsedRouteInfo;
 
         if (!this.hasSecurityRoutes && route.security) {
           this.hasSecurityRoutes = route.security;
@@ -834,48 +803,50 @@ class SchemaRoutes {
           this.hasFormDataRoutes = route.hasFormDataParams;
         }
 
-        this.routes.push(usageRouteData || parsedRouteInfo);
+        this.routes.push(route);
       });
     });
   };
 
   getGroupedRoutes = () => {
-    return _.reduce(
-      this.routes.reduce(
-        (modules, route) => {
-          if (route.namespace) {
-            if (!modules[route.namespace]) {
-              modules[route.namespace] = [];
-            }
-
-            modules[route.namespace].push(route);
-          } else {
-            modules.$outOfModule.push(route);
+    const groupedRoutes = this.routes.reduce(
+      (modules, route) => {
+        if (route.namespace) {
+          if (!modules[route.namespace]) {
+            modules[route.namespace] = [];
           }
 
-          return modules;
-        },
-        {
-          $outOfModule: [],
-        },
-      ),
-      (acc, packRoutes, moduleName) => {
+          modules[route.namespace].push(route);
+        } else {
+          modules.$outOfModule.push(route);
+        }
+
+        return modules;
+      },
+      {
+        $outOfModule: [],
+      },
+    );
+
+    return _.reduce(
+      groupedRoutes,
+      (acc, routesGroup, moduleName) => {
         if (moduleName === "$outOfModule") {
-          acc.outOfModule = packRoutes;
+          acc.outOfModule = routesGroup;
         } else {
           if (!acc.combined) acc.combined = [];
 
           acc.combined.push({
             moduleName,
-            routes: _.map(packRoutes, (route) => {
+            routes: _.map(routesGroup, (route) => {
               const { original: originalName, usage: usageName } = route.routeName;
 
               // TODO: https://github.com/acacode/swagger-typescript-api/issues/152
               // TODO: refactor
               if (
-                packRoutes.length > 1 &&
+                routesGroup.length > 1 &&
                 usageName !== originalName &&
-                !_.some(packRoutes, ({ routeName, id }) => id !== route.id && originalName === routeName.original)
+                !_.some(routesGroup, ({ routeName, id }) => id !== route.id && originalName === routeName.original)
               ) {
                 return {
                   ...route,

package/src/templates.js

@@ -119,31 +119,31 @@ class Templates {
     );
   };
 
+  findTemplateWithExt = (path) => {
+    const raw = this.cropExtension(path);
+    const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
+    return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
+  };
+
   getTemplateContent = (path) => {
     const foundTemplatePathKey = _.keys(this.config.templatePaths).find((key) => _.startsWith(path, `@${key}`));
 
-    const findPathWithExt = (path) => {
-      const raw = this.cropExtension(path);
-      const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
-      return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
-    };
-
     const rawPath = resolve(
       _.replace(path, `@${foundTemplatePathKey}`, this.config.templatePaths[foundTemplatePathKey]),
     );
-    const fixedPath = findPathWithExt(rawPath);
+    const fixedPath = this.findTemplateWithExt(rawPath);
 
     if (fixedPath) {
       return this.fileSystem.getFileContent(fixedPath);
     }
 
-    const customPath = findPathWithExt(resolve(this.config.templatePaths.custom, path));
+    const customPath = this.findTemplateWithExt(resolve(this.config.templatePaths.custom, path));
 
     if (customPath) {
       return this.fileSystem.getFileContent(customPath);
     }
 
-    const originalPath = findPathWithExt(resolve(this.config.templatePaths.original, path));
+    const originalPath = this.findTemplateWithExt(resolve(this.config.templatePaths.original, path));
 
     if (originalPath) {
       return this.fileSystem.getFileContent(originalPath);