fix(schema): fix schema error when enums() is used with a mongoose schema

Author: Romakita

packages/orm/mongoose/src/utils/createSchema.ts

@@ -1,6 +1,6 @@
 import {cleanObject, nameOf, Store, Type} from "@tsed/core";
 import {deserialize, serialize} from "@tsed/json-mapper";
-import {getProperties, JsonEntityStore} from "@tsed/schema";
+import {getProperties, JsonEntityStore, JsonSchema} from "@tsed/schema";
 import {pascalCase} from "change-case";
 import mongoose, {Schema, SchemaDefinition, SchemaOptions, SchemaTypeOptions} from "mongoose";
 import {MONGOOSE_SCHEMA, MONGOOSE_SCHEMA_OPTIONS} from "../constants/constants";
@@ -170,7 +170,7 @@ export function createSchemaTypeOptions<T = any>(propEntity: JsonEntityStore): S
       max,
       minlength,
       maxlength,
-      enum: jsonSchema["enum"],
+      enum: /*jsonSchema["enum"] instanceof JsonSchema ? jsonSchema["enum"].toJSON().enum :*/ jsonSchema["enum"],
       default: jsonSchema["default"]
     };
   } else if (!rawMongooseSchema.ref) {

packages/orm/mongoose/test/enums.integration.spec.ts

@@ -0,0 +1,76 @@
+import {Model} from "@tsed/mongoose";
+import {CollectionOf, Default, Description, Enum, enums, getJsonSchema, MaxLength, MinLength, Required} from "@tsed/schema";
+import {TestMongooseContext} from "@tsed/testing-mongoose";
+
+export enum ComponentStatuses {
+  UNDER_MAINTENANCE = "UNDER_MAINTENANCE",
+  DEGRADED_PERFORMANCE = "DEGRADED_PERFORMANCE",
+  PARTIAL_OUTAGE = "PARTIAL_OUTAGE",
+  MAJOR_OUTAGE = "MAJOR_OUTAGE"
+}
+
+enums(ComponentStatuses).label("ComponentStatuses");
+
+export class ResponseTimeThreshold {
+  @Enum(ComponentStatuses)
+  @Required()
+  @Default(ComponentStatuses.MAJOR_OUTAGE)
+  status: ComponentStatuses = ComponentStatuses.MAJOR_OUTAGE;
+}
+
+@Model({
+  name: "components-statuses-settings"
+})
+export class ComponentStatusSettings {
+  @Required()
+  @Description("The settings name")
+  @MinLength(3)
+  @MaxLength(100)
+  name: string;
+
+  @CollectionOf(ResponseTimeThreshold)
+  responseTimes: ResponseTimeThreshold[];
+}
+
+describe("Enums integration", () => {
+  beforeEach(TestMongooseContext.create);
+  afterEach(TestMongooseContext.clearDatabase);
+  afterEach(TestMongooseContext.reset);
+
+  it("should not fail when the enum is used with enums() utils", () => {
+    expect(getJsonSchema(ComponentStatusSettings)).toEqual({
+      definitions: {
+        ComponentStatuses: {
+          enum: ["UNDER_MAINTENANCE", "DEGRADED_PERFORMANCE", "PARTIAL_OUTAGE", "MAJOR_OUTAGE"],
+          type: "string"
+        },
+        ResponseTimeThreshold: {
+          properties: {
+            status: {
+              $ref: "#/definitions/ComponentStatuses",
+              minLength: 1
+            }
+          },
+          required: ["status"],
+          type: "object"
+        }
+      },
+      properties: {
+        name: {
+          description: "The settings name",
+          maxLength: 100,
+          minLength: 3,
+          type: "string"
+        },
+        responseTimes: {
+          items: {
+            $ref: "#/definitions/ResponseTimeThreshold"
+          },
+          type: "array"
+        }
+      },
+      required: ["name"],
+      type: "object"
+    });
+  });
+});

packages/specs/schema/jest.config.js

@@ -7,7 +7,7 @@ module.exports = {
   coverageThreshold: {
     global: {
       statements: 99.45,
-      branches: 96.13,
+      branches: 96.14,
       functions: 100,
       lines: 99.45
     }

packages/specs/schema/src/components/schemaMapper.ts

@@ -6,6 +6,7 @@ import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
 import {execMapper, hasMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
 import {getRequiredProperties} from "../utils/getRequiredProperties";
 import {alterOneOf} from "../hooks/alterOneOf";
+import {inlineEnums} from "../utils/inlineEnums";
 import {mapNullableType} from "../utils/mapNullableType";
 
 /**
@@ -107,6 +108,7 @@ export function schemaMapper(schema: JsonSchema, options: JsonSchemaOptions): an
   obj = getRequiredProperties(obj, schema, {...options, useAlias});
   obj = mapNullableType(obj, schema, options);
   obj = alterOneOf(obj, schema, options);
+  obj = inlineEnums(obj, schema, options);
 
   return obj;
 }

packages/specs/schema/src/domain/JsonSchema.ts

@@ -934,7 +934,7 @@ export class JsonSchema extends Map<string, any> implements NestedGenerics {
 
     if (!options) {
       addDef = true;
-      options = {schemas: {}};
+      options = {schemas: {}, inlineEnums: true};
     }
 
     const schema = execMapper("schema", this, options);

packages/specs/schema/src/interfaces/JsonSchemaOptions.ts

@@ -28,5 +28,7 @@ export interface JsonSchemaOptions {
    */
   customKeys?: boolean;
 
+  inlineEnums?: boolean;
+
   [key: string]: any;
 }

packages/specs/schema/src/utils/inlineEnums.spec.ts

@@ -0,0 +1,22 @@
+import {inlineEnums} from "./inlineEnums";
+
+describe("inlineEnums()", () => {
+  it("should inline enums", () => {
+    const result = inlineEnums(
+      {
+        enum: {
+          isJsonSchema: true,
+          toJSON() {
+            return {enum: ["type"]};
+          }
+        }
+      },
+      {} as any,
+      {inlineEnums: true}
+    );
+
+    expect(result).toEqual({
+      enum: ["type"]
+    });
+  });
+});

packages/specs/schema/src/utils/inlineEnums.ts

@@ -0,0 +1,10 @@
+import {JsonSchema} from "../domain/JsonSchema";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+
+export function inlineEnums(obj: any, schema: JsonSchema, options: JsonSchemaOptions) {
+  if (options.inlineEnums && obj.enum?.isJsonSchema) {
+    obj.enum = obj.enum.toJSON().enum;
+  }
+
+  return obj;
+}