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

package/src/schema-parser/complex-schema-parsers/any-of.js

@@ -0,0 +1,34 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+
+// T1 | T2 | (T1 & T2)
+class AnyOfSchemaParser extends MonoSchemaParser {
+  parse() {
+    const ignoreTypes = [this.config.Ts.Keyword.Any];
+    const combined = _.map(this.schema.anyOf, (childSchema) =>
+      this.schemaParserFabric.getInlineParseContent(
+        this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema),
+        null,
+        this.schemaPath,
+      ),
+    );
+    const filtered = this.schemaUtils.filterSchemaContents(
+      combined,
+      (content) => !ignoreTypes.includes(content),
+    );
+
+    const type = this.config.Ts.UnionType(
+      _.compact([
+        ...filtered,
+        filtered.length > 1 &&
+          this.config.Ts.ExpressionGroup(
+            this.config.Ts.IntersectionType(filtered),
+          ),
+      ]),
+    );
+
+    return this.schemaUtils.safeAddNullToType(this.schema, type);
+  }
+}
+
+module.exports = { AnyOfSchemaParser };

package/src/schema-parser/complex-schema-parsers/not.js

@@ -0,0 +1,9 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+
+class NotSchemaParser extends MonoSchemaParser {
+  parse() {
+    return this.config.Ts.Keyword.Any;
+  }
+}
+
+module.exports = { NotSchemaParser };

package/src/schema-parser/complex-schema-parsers/one-of.js

@@ -0,0 +1,27 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+
+// T1 | T2
+class OneOfSchemaParser extends MonoSchemaParser {
+  parse() {
+    const ignoreTypes = [this.config.Ts.Keyword.Any];
+    const combined = _.map(this.schema.oneOf, (childSchema) =>
+      this.schemaParserFabric.getInlineParseContent(
+        this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema),
+        null,
+        this.schemaPath,
+      ),
+    );
+
+    const filtered = this.schemaUtils.filterSchemaContents(
+      combined,
+      (content) => !ignoreTypes.includes(content),
+    );
+
+    const type = this.config.Ts.UnionType(filtered);
+
+    return this.schemaUtils.safeAddNullToType(this.schema, type);
+  }
+}
+
+module.exports = { OneOfSchemaParser };

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

@@ -0,0 +1,48 @@
+class MonoSchemaParser {
+  schema;
+  typeName;
+  schemaPath;
+
+  /** @type {Logger} */
+  logger;
+  /** @type {SchemaParser} */
+  schemaParser;
+  /** @type {SchemaParserFabric} */
+  schemaParserFabric;
+  /** @type {TypeNameFormatter} */
+  typeNameFormatter;
+  /** @type {SchemaComponentsMap} */
+  schemaComponentsMap;
+  /** @type {SchemaUtils} */
+  schemaUtils;
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {SchemaFormatters} */
+  schemaFormatters;
+
+  constructor(schemaParser, schema, typeName = null, schemaPath = []) {
+    this.schemaParser = schemaParser;
+    this.schemaParserFabric = schemaParser.schemaParserFabric;
+    this.logger = schemaParser.logger;
+    this.schema = schema;
+    this.typeName = typeName;
+    this.typeNameFormatter = schemaParser.typeNameFormatter;
+    this.schemaPath = schemaPath;
+    this.schemaComponentsMap = this.schemaParser.schemaComponentsMap;
+    this.schemaUtils = this.schemaParser.schemaUtils;
+    this.config = this.schemaParser.config;
+    this.schemaFormatters = this.schemaParser.schemaFormatters;
+  }
+
+  parse() {
+    throw new Error('not implemented');
+  }
+
+  buildTypeNameFromPath = () => {
+    return this.schemaUtils.buildTypeNameFromPath(this.schemaPath);
+  };
+}
+
+module.exports = {
+  MonoSchemaParser,
+};

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

@@ -1,29 +1,24 @@
-const { SCHEMA_TYPES } = require("../constants");
-const _ = require("lodash");
+const { SCHEMA_TYPES } = require('../constants');
+const _ = require('lodash');
 
 class SchemaFormatters {
-  /**
-   * @type {CodeGenConfig}
-   */
+  /** @type {CodeGenConfig} */
   config;
-  /**
-   * @type {Logger}
-   */
+  /** @type {Logger} */
   logger;
+  /** @type {TemplatesWorker} */
+  templatesWorker;
+  /** @type {SchemaUtils} */
+  schemaUtils;
+
   /**
-   * @type {SchemaProcessor}
-   */
-  schemaParser;
-  /**
-   * @type {Templates}
+   * @param schemaParser {SchemaParser | SchemaParserFabric}
    */
-  templates;
-
-  constructor(config, logger, schemaParser, templates) {
-    this.config = config;
-    this.logger = logger;
-    this.schemaParser = schemaParser;
-    this.templates = templates;
+  constructor(schemaParser) {
+    this.config = schemaParser.config;
+    this.logger = schemaParser.logger;
+    this.schemaUtils = schemaParser.schemaUtils;
+    this.templatesWorker = schemaParser.templatesWorker;
   }
 
   base = {
@@ -32,7 +27,9 @@ class SchemaFormatters {
         return {
           ...parsedSchema,
           $content: parsedSchema.content,
-          content: this.config.Ts.UnionType(_.map(parsedSchema.content, ({ value }) => value)),
+          content: this.config.Ts.UnionType(
+            _.map(parsedSchema.content, ({ value }) => value),
+          ),
         };
       }
 
@@ -42,12 +39,13 @@ class SchemaFormatters {
         content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content),
       };
     },
-    [SCHEMA_TYPES.OBJECT]: async (parsedSchema) => {
-      if (parsedSchema.nullable) return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
+    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+      if (parsedSchema.nullable)
+        return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
       return {
         ...parsedSchema,
         $content: parsedSchema.content,
-        content: await this.formatObjectContent(parsedSchema.content),
+        content: this.formatObjectContent(parsedSchema.content),
       };
     },
     [SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
@@ -68,26 +66,31 @@ class SchemaFormatters {
                 ..._.map(parsedSchema.content, ({ value }) => `${value}`),
                 parsedSchema.nullable && this.config.Ts.Keyword.Null,
               ]),
-            ),
+            ) || this.config.Ts.Keyword.Any,
       };
     },
-    [SCHEMA_TYPES.OBJECT]: async (parsedSchema) => {
+    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
       if (_.isString(parsedSchema.content)) {
         return {
           ...parsedSchema,
           typeIdentifier: this.config.Ts.Keyword.Type,
-          content: this.schemaParser.schemaUtils.safeAddNullToType(parsedSchema.content),
+          content: this.schemaUtils.safeAddNullToType(parsedSchema.content),
         };
       }
 
       return {
         ...parsedSchema,
         typeIdentifier: this.config.Ts.Keyword.Type,
-        content: this.schemaParser.schemaUtils.safeAddNullToType(
+        content: this.schemaUtils.safeAddNullToType(
           parsedSchema,
           parsedSchema.content.length
-            ? this.config.Ts.ObjectWrapper(await this.formatObjectContent(parsedSchema.content))
-            : this.config.Ts.RecordType(Ts.Keyword.String, this.config.Ts.Keyword.Any),
+            ? this.config.Ts.ObjectWrapper(
+                this.formatObjectContent(parsedSchema.content),
+              )
+            : this.config.Ts.RecordType(
+                this.config.Ts.Keyword.String,
+                this.config.Ts.Keyword.Any,
+              ),
         ),
       };
     },
@@ -95,23 +98,24 @@ class SchemaFormatters {
 
   /**
    * @param parsedSchema {Record<string, any>}
-   * @param cfg {{ formatType?: "base" | "inline", schemaType?: string } }
+   * @param formatType {"base" | "inline"}
    */
-  formatSchema = async (parsedSchema, { schemaType: outerSchemaType, formatType = "base" } = {}) => {
+  formatSchema = (parsedSchema, formatType = 'base') => {
     const schemaType =
-      outerSchemaType || _.get(parsedSchema, ["schemaType"]) || _.get(parsedSchema, ["$parsed", "schemaType"]);
+      _.get(parsedSchema, ['schemaType']) ||
+      _.get(parsedSchema, ['$parsed', 'schemaType']);
     const formatterFn = _.get(this, [formatType, schemaType]);
-    return (formatterFn && (await formatterFn(parsedSchema))) || parsedSchema;
+    return (formatterFn && formatterFn(parsedSchema)) || parsedSchema;
   };
 
   formatDescription = (description, inline) => {
-    if (!description) return "";
+    if (!description) return '';
 
     let prettified = description;
 
-    prettified = _.replace(prettified, /\*\//g, "*/");
+    prettified = _.replace(prettified, /\*\//g, '*/');
 
-    const hasMultipleLines = _.includes(prettified, "\n");
+    const hasMultipleLines = _.includes(prettified, '\n');
 
     if (!hasMultipleLines) return prettified;
 
@@ -120,35 +124,40 @@ class SchemaFormatters {
         .split(/\n/g)
         .map((part) => _.trim(part))
         .compact()
-        .join(" ")
+        .join(' ')
         .valueOf();
     }
 
-    return _.replace(prettified, /\n$/g, "");
+    return _.replace(prettified, /\n$/g, '');
   };
 
-  formatObjectContent = async (content) => {
-    return (
-      await Promise.all(
-        _.map(content, async (part) => {
-          const extraSpace = "  ";
-          const result = `${extraSpace}${part.field},\n`;
-
-          const renderedJsDoc = await this.templates.renderTemplate(this.config.templatesToRender.dataContractJsDoc, {
-            data: part,
-          });
-
-          const routeNameFromTemplate = renderedJsDoc
-            .split("\n")
-            .map((c) => `${extraSpace}${c}`)
-            .join("\n");
-
-          if (routeNameFromTemplate) return `${routeNameFromTemplate}${result}`;
+  formatObjectContent = (content) => {
+    const fields = [];
+
+    for (const part of content) {
+      const extraSpace = '  ';
+      const result = `${extraSpace}${part.field},\n`;
+
+      const renderedJsDoc = this.templatesWorker.renderTemplate(
+        this.config.templatesToRender.dataContractJsDoc,
+        {
+          data: part,
+        },
+      );
+
+      const routeNameFromTemplate = renderedJsDoc
+        .split('\n')
+        .map((c) => `${extraSpace}${c}`)
+        .join('\n');
+
+      if (routeNameFromTemplate) {
+        fields.push(`${routeNameFromTemplate}${result}`);
+      } else {
+        fields.push(`${result}`);
+      }
+    }
 
-          return `${result}`;
-        }),
-      )
-    ).join("");
+    return fields.join('');
   };
 }
 

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

@@ -0,0 +1,131 @@
+const _ = require('lodash');
+const { SchemaFormatters } = require('./schema-formatters');
+const { SchemaUtils } = require('./schema-utils');
+const { SchemaParser } = require('./schema-parser');
+
+class SchemaParserFabric {
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {Logger} */
+  logger;
+  /** @type {SchemaComponentsMap} */
+  schemaComponentsMap;
+  /** @type {TypeNameFormatter} */
+  typeNameFormatter;
+  /** @type {SchemaFormatters} */
+  schemaFormatters;
+  /** @type {TemplatesWorker} */
+  templatesWorker;
+  /** @type {SchemaUtils} */
+  schemaUtils;
+  /** @type {SchemaWalker} */
+  schemaWalker;
+
+  constructor({
+    config,
+    logger,
+    templatesWorker,
+    schemaComponentsMap,
+    typeNameFormatter,
+    schemaWalker,
+  }) {
+    this.config = config;
+    this.logger = logger;
+    this.schemaComponentsMap = schemaComponentsMap;
+    this.typeNameFormatter = typeNameFormatter;
+    this.templatesWorker = templatesWorker;
+    this.schemaWalker = schemaWalker;
+    this.schemaUtils = new SchemaUtils(this);
+    this.schemaFormatters = new SchemaFormatters(this);
+  }
+
+  createSchemaParser = ({ schema, typeName, schemaPath }) => {
+    return new SchemaParser(this, { schema, typeName, schemaPath });
+  };
+
+  /**
+   *
+   * @param content schema content
+   * @param linkedSchema link content to attached schema
+   * @param linkedComponent link content and other schema props to attached component
+   * @param schemaPath
+   * @param otherSchemaProps
+   * @returns {{}}
+   */
+  createSchema = ({
+    content,
+    linkedSchema = {},
+    linkedComponent,
+    schemaPath,
+    ...otherSchemaProps
+  }) => {
+    const parser = this.createSchemaParser({
+      schema: linkedComponent || linkedSchema,
+      schemaPath,
+    });
+    const parsed = parser.parseSchema();
+    parsed.content = content;
+    Object.assign(parsed, otherSchemaProps);
+    if (linkedComponent) {
+      linkedComponent.typeData = parsed;
+    }
+    return parser.schema;
+  };
+
+  createParsedComponent = ({ typeName, schema, schemaPath }) => {
+    const schemaCopy = _.cloneDeep(schema);
+    const customComponent = this.schemaComponentsMap.createComponent(
+      this.schemaComponentsMap.createRef(['components', 'schemas', typeName]),
+      schemaCopy,
+    );
+    const parsed = this.parseSchema(schemaCopy, null, schemaPath);
+    parsed.name = typeName;
+    customComponent.typeData = parsed;
+
+    return customComponent;
+  };
+
+  /**
+   *
+   * @param schema {any}
+   * @param typeName {null | string}
+   * @param [schemaPath] {string[]}
+   * @return {Record<string, any>}
+   */
+  parseSchema = (schema, typeName = null, schemaPath = []) => {
+    const schemaParser = this.createSchemaParser({
+      schema,
+      typeName,
+      schemaPath,
+    });
+    return schemaParser.parseSchema();
+  };
+
+  /**
+   *
+   * @param schema {any}
+   * @param typeName {null | string}
+   * @param [schemaPath] {string[]}
+   * @return {Record<string, any>}
+   */
+  getInlineParseContent = (schema, typeName, schemaPath) => {
+    const parser = this.createSchemaParser({ schema, typeName, schemaPath });
+    return parser.getInlineParseContent();
+  };
+
+  /**
+   *
+   * @param schema {any}
+   * @param typeName {null | string}
+   * @param [schemaPath] {string[]}
+   * @return {Record<string, any>}
+   */
+  getParseContent = (schema, typeName, schemaPath) => {
+    const parser = this.createSchemaParser({ schema, typeName, schemaPath });
+    return parser.getParseContent();
+  };
+}
+
+module.exports = {
+  SchemaParserFabric,
+};