docusaurus-plugin-openapi-docs 4.0.0 → 4.1.0

package/lib/markdown/createSchema.test.js

@@ -72,6 +72,199 @@ describe("createNodes", () => {
             };
             expect(await Promise.all((0, createSchema_1.createNodes)(schema, "request").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
         });
+        it("should handle oneOf with different primitive types", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        oneOf: [
+                            { type: "string" },
+                            { type: "number" },
+                            { type: "boolean" },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle oneOf with complex types", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    objectProp: { type: "string" },
+                                },
+                            },
+                            {
+                                type: "array",
+                                items: { type: "number" },
+                            },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle nested oneOf clauses", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    nestedOneOfProp: {
+                                        oneOf: [{ type: "string" }, { type: "number" }],
+                                    },
+                                },
+                            },
+                            { type: "boolean" },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        // TypeError: Cannot read properties of undefined (reading 'length')
+        // eslint-disable-next-line jest/no-commented-out-tests
+        // it("should handle oneOf with discriminator", async () => {
+        //   const schema: SchemaObject = {
+        //     type: "object",
+        //     discriminator: { propertyName: "type" },
+        //     properties: {
+        //       type: { type: "string" },
+        //     },
+        //     oneOf: [
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           type: { type: "string", enum: ["typeA"] },
+        //           propA: { type: "string" },
+        //         },
+        //         required: ["type"],
+        //       },
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           type: { type: "string", enum: ["typeB"] },
+        //           propB: { type: "number" },
+        //         },
+        //         required: ["type"],
+        //       },
+        //     ],
+        //   };
+        //   expect(
+        //     await Promise.all(
+        //       createNodes(schema, "response").map(
+        //         async (md: any) => await prettier.format(md, { parser: "babel" })
+        //       )
+        //     )
+        //   ).toMatchSnapshot();
+        // });
+        it("should handle oneOf with shared properties", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    sharedProp: { type: "string" },
+                    oneOfProperty: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    specificPropA: { type: "string" },
+                                },
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    specificPropB: { type: "number" },
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle oneOf with required properties", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    requiredPropA: { type: "string" },
+                                },
+                                required: ["requiredPropA"],
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    requiredPropB: { type: "number" },
+                                },
+                                required: ["requiredPropB"],
+                            },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+    });
+    describe("anyOf", () => {
+        it("should render primitives within anyOf", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        anyOf: [
+                            {
+                                type: "integer",
+                            },
+                            {
+                                type: "boolean",
+                            },
+                        ],
+                        title: "One of int or bool",
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should render oneOf within anyOf", async () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        anyOf: [
+                            {
+                                oneOf: [
+                                    {
+                                        type: "integer",
+                                    },
+                                    {
+                                        type: "boolean",
+                                    },
+                                ],
+                                title: "An int or a bool",
+                            },
+                            {
+                                type: "string",
+                            },
+                        ],
+                        title: "One of int or bool, or a string",
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
     });
     describe("allOf", () => {
         it("should render same-level properties with allOf", async () => {
@@ -289,6 +482,348 @@ describe("createNodes", () => {
         //   ).toMatchSnapshot();
         // });
     });
+    describe("discriminator", () => {
+        it("should handle basic discriminator with oneOf", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with shared properties", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                    sharedProp: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with nested schemas", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            nestedA: {
+                                type: "object",
+                                properties: {
+                                    propA1: { type: "string" },
+                                    propA2: { type: "number" },
+                                },
+                            },
+                        },
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            nestedB: {
+                                type: "object",
+                                properties: {
+                                    propB1: { type: "string" },
+                                    propB2: { type: "boolean" },
+                                },
+                            },
+                        },
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with additional properties", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        additionalProperties: false,
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        additionalProperties: true,
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with allOf", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                },
+                allOf: [
+                    {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    type: { type: "string", enum: ["typeA"] },
+                                    propA: { type: "string" },
+                                },
+                                required: ["type"],
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    type: { type: "string", enum: ["typeB"] },
+                                    propB: { type: "number" },
+                                },
+                                required: ["type"],
+                            },
+                        ],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            sharedProp: { type: "string" },
+                        },
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with required properties", async () => {
+            const schema = {
+                type: "object",
+                discriminator: { propertyName: "type" },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type", "propA"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type", "propB"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle basic discriminator with mapping", async () => {
+            const schema = {
+                type: "object",
+                discriminator: {
+                    propertyName: "type",
+                    mapping: {
+                        typeA: "#/definitions/TypeA",
+                        typeB: "#/definitions/TypeB",
+                    },
+                },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with shared properties and mapping", async () => {
+            const schema = {
+                type: "object",
+                discriminator: {
+                    propertyName: "type",
+                    mapping: {
+                        typeA: "#/definitions/TypeA",
+                        typeB: "#/definitions/TypeB",
+                    },
+                },
+                properties: {
+                    type: { type: "string" },
+                    sharedProp: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with allOf and mapping", async () => {
+            const schema = {
+                type: "object",
+                discriminator: {
+                    propertyName: "type",
+                    mapping: {
+                        typeA: "#/definitions/TypeA",
+                        typeB: "#/definitions/TypeB",
+                    },
+                },
+                properties: {
+                    type: { type: "string" },
+                },
+                allOf: [
+                    {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    type: { type: "string", enum: ["typeA"] },
+                                    propA: { type: "string" },
+                                },
+                                required: ["type"],
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    type: { type: "string", enum: ["typeB"] },
+                                    propB: { type: "number" },
+                                },
+                                required: ["type"],
+                            },
+                        ],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            sharedProp: { type: "string" },
+                        },
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should handle discriminator with required properties and mapping", async () => {
+            const schema = {
+                type: "object",
+                discriminator: {
+                    propertyName: "type",
+                    mapping: {
+                        typeA: "#/definitions/TypeA",
+                        typeB: "#/definitions/TypeB",
+                    },
+                },
+                properties: {
+                    type: { type: "string" },
+                },
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeA"] },
+                            propA: { type: "string" },
+                        },
+                        required: ["type", "propA"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["typeB"] },
+                            propB: { type: "number" },
+                        },
+                        required: ["type", "propB"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+    });
     describe("additionalProperties", () => {
         it.each([
             [

package/lib/markdown/utils.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Children in the plugin does not accept DOM elements, when compared with Children in the theme.
+ * It is designed for rendering HTML a strings.
+ */
 export type Children = string | undefined | (string | string[] | undefined)[];
 export type Props = Record<string, any> & {
     children?: Children;

package/lib/openapi/openapi.js

@@ -61,7 +61,7 @@ async function createPostmanCollection(openapiData) {
     return await jsonToCollection(data);
 }
 function createItems(openapiData, options, sidebarOptions) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7;
     // TODO: Find a better way to handle this
     let items = [];
     const infoIdSpaces = openapiData.info.title.replace(" ", "-").toLowerCase();
@@ -212,15 +212,15 @@ function createItems(openapiData, options, sidebarOptions) {
         }
     }
     // Gather x-webhooks endpoints
-    for (let [path, pathObject] of Object.entries((_p = openapiData["x-webhooks"]) !== null && _p !== void 0 ? _p : {})) {
+    for (let [path, pathObject] of Object.entries((_q = (_p = openapiData["x-webhooks"]) !== null && _p !== void 0 ? _p : openapiData["webhooks"]) !== null && _q !== void 0 ? _q : {})) {
         path = "webhook";
         const { $ref, description, parameters, servers, summary, ...rest } = pathObject;
         for (let [method, operationObject] of Object.entries({ ...rest })) {
             method = "event";
-            const title = (_r = (_q = operationObject.summary) !== null && _q !== void 0 ? _q : operationObject.operationId) !== null && _r !== void 0 ? _r : "Missing summary";
+            const title = (_s = (_r = operationObject.summary) !== null && _r !== void 0 ? _r : operationObject.operationId) !== null && _s !== void 0 ? _s : "Missing summary";
             if (operationObject.description === undefined) {
                 operationObject.description =
-                    (_t = (_s = operationObject.summary) !== null && _s !== void 0 ? _s : operationObject.operationId) !== null && _t !== void 0 ? _t : "";
+                    (_u = (_t = operationObject.summary) !== null && _t !== void 0 ? _t : operationObject.operationId) !== null && _u !== void 0 ? _u : "";
             }
             const baseId = operationObject.operationId
                 ? (0, kebabCase_1.default)(operationObject.operationId)
@@ -232,10 +232,10 @@ function createItems(openapiData, options, sidebarOptions) {
                     extensions.push({ key, value });
                 }
             }
-            const servers = (_v = (_u = operationObject.servers) !== null && _u !== void 0 ? _u : pathObject.servers) !== null && _v !== void 0 ? _v : openapiData.servers;
-            const security = (_w = operationObject.security) !== null && _w !== void 0 ? _w : openapiData.security;
+            const servers = (_w = (_v = operationObject.servers) !== null && _v !== void 0 ? _v : pathObject.servers) !== null && _w !== void 0 ? _w : openapiData.servers;
+            const security = (_x = operationObject.security) !== null && _x !== void 0 ? _x : openapiData.security;
             // Add security schemes so we know how to handle security.
-            const securitySchemes = (_x = openapiData.components) === null || _x === void 0 ? void 0 : _x.securitySchemes;
+            const securitySchemes = (_y = openapiData.components) === null || _y === void 0 ? void 0 : _y.securitySchemes;
             // Make sure schemes are lowercase. See: https://github.com/cloud-annotations/docusaurus-plugin-openapi/issues/79
             if (securitySchemes) {
                 for (let securityScheme of Object.values(securitySchemes)) {
@@ -245,7 +245,7 @@ function createItems(openapiData, options, sidebarOptions) {
                 }
             }
             let jsonRequestBodyExample;
-            const content = (_y = operationObject.requestBody) === null || _y === void 0 ? void 0 : _y.content;
+            const content = (_z = operationObject.requestBody) === null || _z === void 0 ? void 0 : _z.content;
             let body;
             for (let key in content) {
                 if (key.toLowerCase() === "application/json" ||
@@ -258,7 +258,7 @@ function createItems(openapiData, options, sidebarOptions) {
                 jsonRequestBodyExample = (0, createRequestExample_1.sampleRequestFromSchema)(body.schema);
             }
             // Handle vendor JSON media types
-            const bodyContent = (_z = operationObject.requestBody) === null || _z === void 0 ? void 0 : _z.content;
+            const bodyContent = (_0 = operationObject.requestBody) === null || _0 === void 0 ? void 0 : _0.content;
             if (bodyContent) {
                 const firstBodyContentKey = Object.keys(bodyContent)[0];
                 if (firstBodyContentKey.endsWith("+json")) {
@@ -325,13 +325,13 @@ function createItems(openapiData, options, sidebarOptions) {
         }
     }
     if ((options === null || options === void 0 ? void 0 : options.showSchemas) === true ||
-        Object.entries((_1 = (_0 = openapiData === null || openapiData === void 0 ? void 0 : openapiData.components) === null || _0 === void 0 ? void 0 : _0.schemas) !== null && _1 !== void 0 ? _1 : {})
+        Object.entries((_2 = (_1 = openapiData === null || openapiData === void 0 ? void 0 : openapiData.components) === null || _1 === void 0 ? void 0 : _1.schemas) !== null && _2 !== void 0 ? _2 : {})
             .flatMap(([_, s]) => s["x-tags"])
             .filter((item) => !!item).length > 0) {
         // Gather schemas
-        for (let [schema, schemaObject] of Object.entries((_3 = (_2 = openapiData === null || openapiData === void 0 ? void 0 : openapiData.components) === null || _2 === void 0 ? void 0 : _2.schemas) !== null && _3 !== void 0 ? _3 : {})) {
+        for (let [schema, schemaObject] of Object.entries((_4 = (_3 = openapiData === null || openapiData === void 0 ? void 0 : openapiData.components) === null || _3 === void 0 ? void 0 : _3.schemas) !== null && _4 !== void 0 ? _4 : {})) {
             if ((options === null || options === void 0 ? void 0 : options.showSchemas) === true || schemaObject["x-tags"]) {
-                const baseIdSpaces = (_5 = (_4 = schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject.title) === null || _4 === void 0 ? void 0 : _4.replace(" ", "-").toLowerCase()) !== null && _5 !== void 0 ? _5 : "";
+                const baseIdSpaces = (_6 = (_5 = schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject.title) === null || _5 === void 0 ? void 0 : _5.replace(" ", "-").toLowerCase()) !== null && _6 !== void 0 ? _6 : "";
                 const baseId = (0, kebabCase_1.default)(baseIdSpaces);
                 const schemaDescription = schemaObject.description;
                 let splitDescription;
@@ -364,7 +364,7 @@ function createItems(openapiData, options, sidebarOptions) {
     }
     if ((sidebarOptions === null || sidebarOptions === void 0 ? void 0 : sidebarOptions.categoryLinkSource) === "tag") {
         // Get global tags
-        const tags = (_6 = openapiData.tags) !== null && _6 !== void 0 ? _6 : [];
+        const tags = (_7 = openapiData.tags) !== null && _7 !== void 0 ? _7 : [];
         // Get operation tags
         const apiItems = items.filter((item) => {
             return item.type === "api";

package/lib/openapi/types.d.ts

@@ -12,6 +12,7 @@ export interface OpenApiObject {
     tags?: TagObject[];
     externalDocs?: ExternalDocumentationObject;
     swagger?: string;
+    webhooks?: PathsObject;
     "x-webhooks"?: PathsObject;
     "x-tagGroups"?: TagGroupObject[];
 }
@@ -163,6 +164,7 @@ export interface ParameterObject {
     examples?: Map<ExampleObject>;
     content?: Map<MediaTypeObject>;
     param?: Object;
+    "x-enumDescriptions"?: Record<string, string>;
 }
 export interface ParameterObjectWithRef {
     name: string;
@@ -279,6 +281,7 @@ export type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf"
     example?: any;
     deprecated?: boolean;
     "x-tags"?: string[];
+    "x-enumDescriptions"?: Record<string, string>;
 };
 export type SchemaObjectWithRef = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
     type?: "string" | "number" | "integer" | "boolean" | "object" | "array";

package/lib/openapi/utils/services/OpenAPIParser.js

@@ -215,7 +215,7 @@ class OpenAPIParser {
         })
             .filter((child) => child !== undefined);
         for (const { $ref: subSchemaRef, schema: subSchema } of allOfSchemas) {
-            const { type, enum: enumProperty, properties, items, required, oneOf, anyOf, title, ...otherConstraints } = subSchema;
+            const { type, enum: enumProperty, "x-enumDescription": enumDescription, properties, items, required, oneOf, anyOf, title, ...otherConstraints } = subSchema;
             if (receiver.type !== type &&
                 receiver.type !== undefined &&
                 type !== undefined) {