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

package/README.md

@@ -399,16 +399,15 @@ generateApi({
 ### `primitiveTypeConstructs`  
 
 It is type mapper or translator swagger schema objects. `primitiveTypeConstructs` translates `type`/`format` schema fields to typescript structs.  
-This option has type  
+This option has type
+
 ```ts
 type PrimitiveTypeStructValue =
-  | string
-  | ((schema: Record<string, any>, parser: import("./src/schema-parser/schema-parser").SchemaParser) => string);
+    | string
+    | ((schema: Record<string, any>, parser: import("./schema-parser-engine").SchemaProcessor) => string);
 
-type PrimitiveTypeStruct = Record<
-  "integer" | "number" | "boolean" | "object" | "file" | "string" | "array",
-  string | ({ $default: PrimitiveTypeStructValue } & Record<string, PrimitiveTypeStructValue>)
->
+type PrimitiveTypeStruct = Record<"integer" | "number" | "boolean" | "object" | "file" | "string" | "array",
+    string | ({ $default: PrimitiveTypeStructValue } & Record<string, PrimitiveTypeStructValue>)>
 
 declare const primitiveTypeConstructs: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>
 
@@ -443,8 +442,8 @@ generateApi({
             "relative-json-pointer": () => "string",
             regex: () => "string",
         },
-        array: (schema, parser) => {
-            const content = parser.getInlineParseContent(schema.items);
+        array: async (schema, parser) => {
+            const content = await parser.getInlineParseContent(schema.items);
             return parser.safeAddNullToType(schema, `(${content})[]`);
         },
     })

package/index.d.ts

@@ -201,7 +201,7 @@ type CodeGenConstruct = {
 
 type PrimitiveTypeStructValue =
   | string
-  | ((schema: Record<string, any>, parser: import("./src/schema-parser/schema-parser").SchemaParser) => string);
+  | ((schema: Record<string, any>, parser: import("./src/schema-parser/schema-processor").SchemaProcessor) => string);
 
 type PrimitiveTypeStruct = Record<
   "integer" | "number" | "boolean" | "object" | "file" | "string" | "array",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-typescript-api",
-  "version": "12.0.1",
+  "version": "13.0.0-experimental-1",
   "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/code-gen-process.js

@@ -2,9 +2,9 @@ const { SwaggerSchemaResolver } = require("./swagger-schema-resolver.js");
 const { SchemaComponentsMap } = require("./schema-components-map.js");
 const { NameResolver } = require("./util/name-resolver");
 const { Logger } = require("./util/logger.js");
-const { TypeName } = require("./type-name.js");
+const { TypeNameFormatter } = require("./type-name-formatter.js");
 const _ = require("lodash");
-const { SchemaParser } = require("./schema-parser/schema-parser.js");
+const { SchemaProcessor } = require("./schema-parser/schema-processor.js");
 const { SchemaRoutes } = require("./schema-parser/schema-routes.js");
 const { CodeGenConfig } = require("./configuration.js");
 const { FileSystem } = require("./util/file-system");
@@ -33,11 +33,11 @@ class CodeGenProcess {
    */
   logger;
   /**
-   * @type {TypeName}
+   * @type {TypeNameFormatter}
    */
   typeName;
   /**
-   * @type {SchemaParser}
+   * @type {SchemaProcessor}
    */
   schemaParser;
   /**
@@ -63,10 +63,10 @@ class CodeGenProcess {
     this.fileSystem = new FileSystem();
     this.swaggerSchemaResolver = new SwaggerSchemaResolver(this.config, this.logger, this.fileSystem);
     this.schemaComponentMap = new SchemaComponentsMap(this.config);
-    this.typeName = new TypeName(this.config, this.logger);
+    this.typeName = new TypeNameFormatter(this.config, this.logger);
     this.templates = new Templates(this.config, this.logger, this.fileSystem, this.getRenderTemplateData);
     this.codeFormatter = new CodeFormatter(this.config);
-    this.schemaParser = new SchemaParser(
+    this.schemaParser = new SchemaProcessor(
       this.config,
       this.logger,
       this.templates,
@@ -85,6 +85,7 @@ class CodeGenProcess {
   }
 
   async start() {
+    await this.schemaRoutes.init();
     this.config.update({ templatePaths: this.templates.getTemplatePaths(this.config) });
     this.config.update({ templatesToRender: this.templates.getTemplates(this.config) });
 
@@ -107,11 +108,13 @@ class CodeGenProcess {
 
     this.config.componentTypeNameResolver.reserve(componentSchemaNames);
 
-    const parsedSchemas = _.map(_.get(swagger.usageSchema.components, "schemas"), (schema, typeName) =>
-      this.schemaParser.parseSchema(schema, typeName),
+    const parsedSchemas = await Promise.all(
+      _.map(_.get(swagger.usageSchema.components, "schemas"), (schema, typeName) =>
+        this.schemaParser.parseSchema(schema, typeName),
+      ),
     );
 
-    this.schemaRoutes.attachSchema({
+    await this.schemaRoutes.attachSchema({
       usageSchema: swagger.usageSchema,
       parsedSchemas,
     });
@@ -150,10 +153,14 @@ class CodeGenProcess {
       return schemas;
     };
 
+    const modelTypes = (await Promise.all(_.map(sortSchemas(usageComponentSchemas), this.prepareModelType))).filter(
+      Boolean,
+    );
+
     const rawConfiguration = {
       apiConfig: this.createApiConfig(swagger.usageSchema),
       config: this.config,
-      modelTypes: _.map(sortSchemas(usageComponentSchemas), this.prepareModelType).filter(Boolean),
+      modelTypes: modelTypes,
       rawModelTypes: usageComponentSchemas,
       hasSecurityRoutes: this.schemaRoutes.hasSecurityRoutes,
       hasQueryRoutes: this.schemaRoutes.hasQueryRoutes,
@@ -178,7 +185,7 @@ class CodeGenProcess {
       this.fileSystem.createDir(this.config.output);
     }
 
-    const files = this.generateOutputFiles({
+    const files = await this.generateOutputFiles({
       configuration: configuration,
     });
 
@@ -218,7 +225,7 @@ class CodeGenProcess {
       files: generatedFiles,
       configuration,
       getTemplate: this.templates.getTemplate,
-      renderTemplate: this.templates.renderTemplate,
+      renderTemplate: await this.templates.renderTemplate,
       createFile: this.fileSystem.createFile,
       formatTSContent: this.codeFormatter.formatCode,
     };
@@ -253,14 +260,15 @@ class CodeGenProcess {
     };
   };
 
-  prepareModelType = (typeInfo) => {
+  prepareModelType = async (typeInfo) => {
     if (!typeInfo.typeData) {
-      typeInfo.typeData = this.schemaParser.parseSchema(typeInfo.rawTypeData, typeInfo.typeName);
+      typeInfo.typeData = await this.schemaParser.parseSchema(typeInfo.rawTypeData, typeInfo.typeName);
     }
-    const rawTypeData = typeInfo.typeData;
-    const typeData = this.schemaParser.schemaFormatters.base[rawTypeData.type]
-      ? this.schemaParser.schemaFormatters.base[rawTypeData.type](rawTypeData)
-      : rawTypeData;
+    const typeData = await this.schemaParser.schemaFormatters.formatSchema(typeInfo.typeData, {
+      formatType: "base",
+      schemaType: typeInfo.typeData.type,
+    });
+
     let { typeIdentifier, name: originalName, content, description } = typeData;
     const name = this.typeName.format(originalName);
 
@@ -271,43 +279,48 @@ class CodeGenProcess {
       typeIdentifier,
       name,
       description,
-      $content: rawTypeData.content,
-      rawContent: rawTypeData.content,
+      $content: typeInfo.typeData.content,
+      rawContent: typeInfo.typeData.content,
       content: content,
       typeData,
     };
   };
 
-  generateOutputFiles = ({ configuration }) => {
+  generateOutputFiles = async ({ configuration }) => {
     const { modular, templatesToRender } = this.config;
 
     const output = modular
-      ? this.createMultipleFileInfos(templatesToRender, configuration)
-      : this.createSingleFileInfo(templatesToRender, configuration);
+      ? await this.createMultipleFileInfos(templatesToRender, configuration)
+      : await this.createSingleFileInfo(templatesToRender, configuration);
 
     if (!_.isEmpty(configuration.extraTemplates)) {
       output.push(
-        ..._.map(configuration.extraTemplates, (extraTemplate) => {
-          return this.createOutputFileInfo(
-            configuration,
-            extraTemplate.name,
-            this.templates.renderTemplate(this.fileSystem.getFileContent(extraTemplate.path), configuration),
-          );
-        }),
+        ...(await Promise.all(
+          _.map(configuration.extraTemplates, async (extraTemplate) => {
+            return this.createOutputFileInfo(
+              configuration,
+              extraTemplate.name,
+              await await this.templates.renderTemplate(
+                this.fileSystem.getFileContent(extraTemplate.path),
+                configuration,
+              ),
+            );
+          }),
+        )),
       );
     }
 
     return output.filter((fileInfo) => !!fileInfo && !!fileInfo.content);
   };
 
-  createMultipleFileInfos = (templatesToRender, configuration) => {
+  createMultipleFileInfos = async (templatesToRender, configuration) => {
     const { routes } = configuration;
     const { fileNames, generateRouteTypes, generateClient } = configuration.config;
     const modularApiFileInfos = [];
 
     if (routes.$outOfModule) {
       if (generateRouteTypes) {
-        const outOfModuleRouteContent = this.templates.renderTemplate(templatesToRender.routeTypes, {
+        const outOfModuleRouteContent = await this.templates.renderTemplate(templatesToRender.routeTypes, {
           ...configuration,
           route: configuration.routes.$outOfModule,
         });
@@ -317,7 +330,7 @@ class CodeGenProcess {
         );
       }
       if (generateClient) {
-        const outOfModuleApiContent = this.templates.renderTemplate(templatesToRender.api, {
+        const outOfModuleApiContent = await this.templates.renderTemplate(templatesToRender.api, {
           ...configuration,
           route: configuration.routes.$outOfModule,
         });
@@ -329,56 +342,48 @@ class CodeGenProcess {
     }
 
     if (routes.combined) {
-      modularApiFileInfos.push(
-        ..._.reduce(
-          routes.combined,
-          (apiFileInfos, route) => {
-            if (generateRouteTypes) {
-              const routeModuleContent = this.templates.renderTemplate(templatesToRender.routeTypes, {
-                ...configuration,
-                route,
-              });
-
-              apiFileInfos.push(
-                this.createOutputFileInfo(configuration, pascalCase(`${route.moduleName}_Route`), routeModuleContent),
-              );
-            }
-
-            if (generateClient) {
-              const apiModuleContent = this.templates.renderTemplate(templatesToRender.api, {
-                ...configuration,
-                route,
-              });
-
-              apiFileInfos.push(
-                this.createOutputFileInfo(configuration, pascalCase(route.moduleName), apiModuleContent),
-              );
-            }
-
-            return apiFileInfos;
-          },
-          [],
-        ),
-      );
+      for await (const route of routes.combined) {
+        if (generateRouteTypes) {
+          const routeModuleContent = await this.templates.renderTemplate(templatesToRender.routeTypes, {
+            ...configuration,
+            route,
+          });
+
+          modularApiFileInfos.push(
+            this.createOutputFileInfo(configuration, pascalCase(`${route.moduleName}_Route`), routeModuleContent),
+          );
+        }
+
+        if (generateClient) {
+          const apiModuleContent = await this.templates.renderTemplate(templatesToRender.api, {
+            ...configuration,
+            route,
+          });
+
+          modularApiFileInfos.push(
+            this.createOutputFileInfo(configuration, pascalCase(route.moduleName), apiModuleContent),
+          );
+        }
+      }
     }
 
     return [
       this.createOutputFileInfo(
         configuration,
         fileNames.dataContracts,
-        this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
+        await this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
       ),
       generateClient &&
         this.createOutputFileInfo(
           configuration,
           fileNames.httpClient,
-          this.templates.renderTemplate(templatesToRender.httpClient, configuration),
+          await this.templates.renderTemplate(templatesToRender.httpClient, configuration),
         ),
       ...modularApiFileInfos,
     ];
   };
 
-  createSingleFileInfo = (templatesToRender, configuration) => {
+  createSingleFileInfo = async (templatesToRender, configuration) => {
     const { generateRouteTypes, generateClient } = configuration.config;
 
     return [
@@ -386,10 +391,10 @@ class CodeGenProcess {
         configuration,
         configuration.fileName,
         _.compact([
-          this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
-          generateRouteTypes && this.templates.renderTemplate(templatesToRender.routeTypes, configuration),
-          generateClient && this.templates.renderTemplate(templatesToRender.httpClient, configuration),
-          generateClient && this.templates.renderTemplate(templatesToRender.api, configuration),
+          await this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
+          generateRouteTypes && (await this.templates.renderTemplate(templatesToRender.routeTypes, configuration)),
+          generateClient && (await this.templates.renderTemplate(templatesToRender.httpClient, configuration)),
+          generateClient && (await this.templates.renderTemplate(templatesToRender.api, configuration)),
         ]).join("\n"),
       ),
     ];

package/src/configuration.js

@@ -263,7 +263,7 @@ class CodeGenConfig {
   /**
    * swagger schema type -> typescript type
    * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
-   * @type {Record<string, string | ((schema: any, parser: SchemaParser) => string) | ({ $default: string } & Record<string, string | ((schema: any, parser: SchemaParser) => string)>)>}
+   * @type {Record<string, string | ((schema: any, parser: SchemaProcessor) => string) | ({ $default: string } & Record<string, string | ((schema: any, parser: SchemaParser) => string)>)>}
    */
   primitiveTypes = {
     integer: () => this.Ts.Keyword.Number,
@@ -294,10 +294,6 @@ class CodeGenConfig {
       "relative-json-pointer": () => this.Ts.Keyword.String,
       regex: () => this.Ts.Keyword.String,
     },
-    array: ({ items, ...schemaPart }, parser) => {
-      const content = parser.getInlineParseContent(items);
-      return parser.schemaUtils.safeAddNullToType(schemaPart, this.Ts.ArrayType(content));
-    },
   };
 
   templateInfos = [

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

@@ -11,7 +11,7 @@ class SchemaFormatters {
    */
   logger;
   /**
-   * @type {SchemaParser}
+   * @type {SchemaProcessor}
    */
   schemaParser;
   /**
@@ -42,12 +42,12 @@ class SchemaFormatters {
         content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content),
       };
     },
-    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    [SCHEMA_TYPES.OBJECT]: async (parsedSchema) => {
       if (parsedSchema.nullable) return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
       return {
         ...parsedSchema,
         $content: parsedSchema.content,
-        content: this.formatObjectContent(parsedSchema.content),
+        content: await this.formatObjectContent(parsedSchema.content),
       };
     },
     [SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
@@ -71,7 +71,7 @@ class SchemaFormatters {
             ),
       };
     },
-    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    [SCHEMA_TYPES.OBJECT]: async (parsedSchema) => {
       if (_.isString(parsedSchema.content)) {
         return {
           ...parsedSchema,
@@ -86,7 +86,7 @@ class SchemaFormatters {
         content: this.schemaParser.schemaUtils.safeAddNullToType(
           parsedSchema,
           parsedSchema.content.length
-            ? this.config.Ts.ObjectWrapper(this.formatObjectContent(parsedSchema.content))
+            ? this.config.Ts.ObjectWrapper(await this.formatObjectContent(parsedSchema.content))
             : this.config.Ts.RecordType(Ts.Keyword.String, this.config.Ts.Keyword.Any),
         ),
       };
@@ -95,12 +95,13 @@ class SchemaFormatters {
 
   /**
    * @param parsedSchema {Record<string, any>}
-   * @param formatType {"base" | "inline"}
+   * @param cfg {{ formatType?: "base" | "inline", schemaType?: string } }
    */
-  formatSchema = (parsedSchema, formatType = "base") => {
-    const schemaType = _.get(parsedSchema, ["schemaType"]) || _.get(parsedSchema, ["$parsed", "schemaType"]);
+  formatSchema = async (parsedSchema, { schemaType: outerSchemaType, formatType = "base" } = {}) => {
+    const schemaType =
+      outerSchemaType || _.get(parsedSchema, ["schemaType"]) || _.get(parsedSchema, ["$parsed", "schemaType"]);
     const formatterFn = _.get(this, [formatType, schemaType]);
-    return (formatterFn && formatterFn(parsedSchema)) || parsedSchema;
+    return (formatterFn && (await formatterFn(parsedSchema))) || parsedSchema;
   };
 
   formatDescription = (description, inline) => {
@@ -126,24 +127,28 @@ class SchemaFormatters {
     return _.replace(prettified, /\n$/g, "");
   };
 
-  formatObjectContent = (content) => {
-    return _.map(content, (part) => {
-      const extraSpace = "  ";
-      const result = `${extraSpace}${part.field},\n`;
+  formatObjectContent = async (content) => {
+    return (
+      await Promise.all(
+        _.map(content, async (part) => {
+          const extraSpace = "  ";
+          const result = `${extraSpace}${part.field},\n`;
 
-      const renderedJsDoc = this.templates.renderTemplate(this.config.templatesToRender.dataContractJsDoc, {
-        data: part,
-      });
+          const renderedJsDoc = await this.templates.renderTemplate(this.config.templatesToRender.dataContractJsDoc, {
+            data: part,
+          });
 
-      const routeNameFromTemplate = renderedJsDoc
-        .split("\n")
-        .map((c) => `${extraSpace}${c}`)
-        .join("\n");
+          const routeNameFromTemplate = renderedJsDoc
+            .split("\n")
+            .map((c) => `${extraSpace}${c}`)
+            .join("\n");
 
-      if (routeNameFromTemplate) return `${routeNameFromTemplate}${result}`;
+          if (routeNameFromTemplate) return `${routeNameFromTemplate}${result}`;
 
-      return `${result}`;
-    }).join("");
+          return `${result}`;
+        }),
+      )
+    ).join("");
   };
 }