feat: discriminator mapping draft

js2me · js2me · commit d5ee69314a4e · 2022-11-15T04:16:59.000+06:00
diff --git a/package.json b/package.json
@@ -60,7 +60,8 @@
     "test:another-query-params": "node tests/spec/another-query-params/test.js",
     "test:on-insert-path-param": "node tests/spec/on-insert-path-param/test.js",
     "test:extra-templates": "node tests/spec/extra-templates/test.js",
-    "test:extract-enums": "node tests/spec/extract-enums/test.js"
+    "test:extract-enums": "node tests/spec/extract-enums/test.js",
+    "test:discriminator": "node tests/spec/discriminator/test.js"
   },
   "author": "acacode",
   "license": "MIT",
diff --git a/src/constants.js b/src/constants.js
@@ -12,6 +12,7 @@ const SCHEMA_TYPES = {
   REF: "$ref",
   PRIMITIVE: "primitive",
   COMPLEX: "complex",
+  DISCRIMINATOR: "discriminator",
   COMPLEX_ONE_OF: "oneOf",
   COMPLEX_ANY_OF: "anyOf",
   COMPLEX_ALL_OF: "allOf",
diff --git a/src/schema-components-map.js b/src/schema-components-map.js
@@ -23,8 +23,12 @@ class SchemaComponentsMap {
     );
   }
 
+  createRef = (componentName, typeName) => {
+    return `#/components/${componentName}/${typeName}`;
+  };
+
   createComponent(componentName, typeName, rawTypeData) {
-    const $ref = `#/components/${componentName}/${typeName}`;
+    const $ref = this.createRef(componentName, typeName);
 
     const componentSchema = {
       $ref,
diff --git a/src/schema-parser/schema-parser.js b/src/schema-parser/schema-parser.js
@@ -256,10 +256,88 @@ class SchemaParser {
         content: type === this.config.Ts.Keyword.Null ? type : contentType || this.getSchemaType(schema),
       };
     },
+    [SCHEMA_TYPES.DISCRIMINATOR]: (schema, typeName) => {
+      const { discriminator, ...noDiscriminatorSchema } = schema;
+
+      if (typeName == null || !discriminator.mapping) return this.parseSchema(noDiscriminatorSchema, typeName);
+
+      const refPath = this.schemaComponentsMap.createRef("schemas", typeName);
+      const complexSchemaKeys = _.keys(this.complexSchemaParsers);
+      const abstractSchema = _.omit(_.clone(noDiscriminatorSchema), complexSchemaKeys);
+      const discTypeName = this.config.componentTypeNameResolver.resolve([
+        pascalCase(`Abstract ${typeName}`),
+        pascalCase(`Discriminator ${typeName}`),
+        pascalCase(`Internal ${typeName}`),
+        pascalCase(`Polymorph ${typeName}`),
+      ]);
+      const abstractSchemaIsEmpty = !_.keys(abstractSchema).length;
+      const abstractComponent =
+        !abstractSchemaIsEmpty &&
+        this.schemaComponentsMap.createComponent("schemas", discTypeName, {
+          ...abstractSchema,
+          internal: true,
+        });
+      const complexType = this.getComplexType(schema);
+
+      const abstractSchemaContent = !abstractSchemaIsEmpty && this.getInlineParseContent(abstractComponent);
+      const complexSchemaContent =
+        complexType !== SCHEMA_TYPES.COMPLEX_UNKNOWN
+          ? this.config.Ts.ExpressionGroup(this.complexSchemaParsers[complexType](schema))
+          : null;
+      const discriminatorSchemaContent =
+        discriminator.mapping &&
+        this.config.Ts.ExpressionGroup(
+          this.config.Ts.UnionType(
+            _.map(discriminator.mapping, (schema, key) => {
+              const mappingSchema = typeof schema === "string" ? { $ref: schema } : schema;
+              if (mappingSchema.$ref) {
+                const mappingRefSchema = this.schemaUtils.getSchemaRefType(mappingSchema)?.rawTypeData;
+                if (mappingRefSchema) {
+                  complexSchemaKeys.forEach((schemaKey) => {
+                    if (_.isArray(mappingRefSchema[schemaKey])) {
+                      mappingRefSchema[schemaKey] = mappingRefSchema[schemaKey].map((schema) => {
+                        if (schema.$ref === refPath) {
+                          return { ...schema, $ref: abstractComponent.$ref };
+                        }
+                        return schema;
+                      });
+                    }
+                  });
+                }
+              }
+              return this.config.Ts.ExpressionGroup(
+                this.config.Ts.IntersectionType([
+                  this.config.Ts.ObjectWrapper(
+                    this.config.Ts.TypeField({
+                      key: discriminator.propertyName,
+                      value: this.config.Ts.StringValue(key),
+                    }),
+                  ),
+                  this.getInlineParseContent(mappingSchema),
+                ]),
+              );
+            }),
+          ),
+        );
+
+      return {
+        ...(_.isObject(schema) ? schema : {}),
+        $parsedSchema: true,
+        schemaType: SCHEMA_TYPES.COMPLEX,
+        type: SCHEMA_TYPES.PRIMITIVE,
+        typeIdentifier: this.config.Ts.Keyword.Type,
+        name: typeName,
+        description: this.schemaFormatters.formatDescription(schema.description),
+        content: this.config.Ts.UnionType(
+          [abstractSchemaContent, complexSchemaContent, discriminatorSchemaContent].filter(Boolean),
+        ),
+      };
+    },
   };
 
   getInternalSchemaType = (schema) => {
     if (!_.isEmpty(schema.enum) || !_.isEmpty(this.schemaUtils.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
+    if (schema.discriminator) return SCHEMA_TYPES.DISCRIMINATOR;
     if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES.COMPLEX;
     if (!_.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
 
diff --git a/templates/base/data-contracts.ejs b/templates/base/data-contracts.ejs
@@ -22,7 +22,7 @@ type <%~ config.Ts.CodeGenKeyword.UtilRequiredKeys %><T, K extends keyof T> = Om
 
 <% modelTypes.forEach((contract) => { %>
   <%~ includeFile('@base/data-contract-jsdoc.ejs', { ...it, data: { ...contract, ...contract.typeData } }) %>
-  export <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
+  <%~ contract.internal ? '' : 'export'%> <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
 
 
 <% }) %>
diff --git a/tests/spec/discriminator/expected.ts b/tests/spec/discriminator/expected.ts
@@ -0,0 +1,75 @@
+/* eslint-disable */
+/* tslint:disable */
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+
+export type SimpleDiscriminator = SimpleObject | ComplexObject;
+
+export interface SimpleObject {
+  objectType: string;
+}
+
+export interface ComplexObject {
+  objectType: string;
+}
+
+export type BlockDTO =
+  | AbstractBlockDto
+  | (CsvBlockDTO | FileBlockDTO)
+  | (
+      | ({
+          type: "csv";
+        } & CsvBlockDTO)
+      | ({
+          type: "file";
+        } & FileBlockDTO)
+    );
+
+export type CsvBlockDTO = AbstractBlockDto & {
+  /** @default "csv" */
+  type: "csv";
+  text: string;
+};
+
+export type FileBlockDTO = AbstractBlockDto & {
+  /** @default "file" */
+  type: "file";
+  fileId: string;
+};
+
+export type Pet =
+  | AbstractPet
+  | (
+      | ({
+          pet_type: "cachorro";
+        } & Dog)
+      | ({
+          pet_type: "cat";
+        } & Cat)
+    );
+
+export type Cat = AbstractPet & {
+  name?: string;
+};
+
+export type Dog = AbstractPet & {
+  bark?: string;
+};
+
+export type Lizard = Pet & {
+  lovesRocks?: boolean;
+};
+
+interface AbstractBlockDto {
+  title: string;
+}
+
+interface AbstractPet {
+  pet_type: string;
+}
diff --git a/tests/spec/discriminator/schema.json b/tests/spec/discriminator/schema.json
diff --git a/tests/spec/discriminator/schema.ts b/tests/spec/discriminator/schema.ts
diff --git a/tests/spec/discriminator/test.js b/tests/spec/discriminator/test.js
