docusaurus-plugin-openapi-docs 2.2.2 → 2.2.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -81,6 +81,10 @@ function createAnyOneOf(schema) {
|
|
|
81
81
|
anyOneChildren.push(createNodes(anyOneSchema, SCHEMA_TYPE));
|
|
82
82
|
delete anyOneSchema.allOf;
|
|
83
83
|
}
|
|
84
|
+
if (anyOneSchema.oneOf !== undefined) {
|
|
85
|
+
anyOneChildren.push(createNodes(anyOneSchema, SCHEMA_TYPE));
|
|
86
|
+
delete anyOneSchema.oneOf;
|
|
87
|
+
}
|
|
84
88
|
if (anyOneSchema.items !== undefined) {
|
|
85
89
|
anyOneChildren.push(createItems(anyOneSchema));
|
|
86
90
|
delete anyOneSchema.items;
|
|
@@ -440,8 +444,9 @@ function createPropertyDiscriminator(name, schemaName, schema, discriminator, re
|
|
|
440
444
|
if (schema === undefined) {
|
|
441
445
|
return undefined;
|
|
442
446
|
}
|
|
447
|
+
// render as a simple property if there's no mapping
|
|
443
448
|
if (discriminator.mapping === undefined) {
|
|
444
|
-
return
|
|
449
|
+
return createEdges({ name, schema, required });
|
|
445
450
|
}
|
|
446
451
|
return (0, utils_1.create)("div", {
|
|
447
452
|
className: "openapi-discriminator__item openapi-schema__list-item",
|
|
@@ -73,6 +73,54 @@ describe("createNodes", () => {
|
|
|
73
73
|
expect(await Promise.all((0, createSchema_1.createNodes)(schema, "request").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
|
|
74
74
|
});
|
|
75
75
|
});
|
|
76
|
+
describe("anyOf", () => {
|
|
77
|
+
it("should render primitives within anyOf", async () => {
|
|
78
|
+
const schema = {
|
|
79
|
+
type: "object",
|
|
80
|
+
properties: {
|
|
81
|
+
oneOfProperty: {
|
|
82
|
+
anyOf: [
|
|
83
|
+
{
|
|
84
|
+
type: "integer",
|
|
85
|
+
},
|
|
86
|
+
{
|
|
87
|
+
type: "boolean",
|
|
88
|
+
},
|
|
89
|
+
],
|
|
90
|
+
title: "One of int or bool",
|
|
91
|
+
},
|
|
92
|
+
},
|
|
93
|
+
};
|
|
94
|
+
expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
|
|
95
|
+
});
|
|
96
|
+
it("should render oneOf within anyOf", async () => {
|
|
97
|
+
const schema = {
|
|
98
|
+
type: "object",
|
|
99
|
+
properties: {
|
|
100
|
+
oneOfProperty: {
|
|
101
|
+
anyOf: [
|
|
102
|
+
{
|
|
103
|
+
oneOf: [
|
|
104
|
+
{
|
|
105
|
+
type: "integer",
|
|
106
|
+
},
|
|
107
|
+
{
|
|
108
|
+
type: "boolean",
|
|
109
|
+
},
|
|
110
|
+
],
|
|
111
|
+
title: "An int or a bool",
|
|
112
|
+
},
|
|
113
|
+
{
|
|
114
|
+
type: "string",
|
|
115
|
+
},
|
|
116
|
+
],
|
|
117
|
+
title: "One of int or bool, or a string",
|
|
118
|
+
},
|
|
119
|
+
},
|
|
120
|
+
};
|
|
121
|
+
expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
|
|
122
|
+
});
|
|
123
|
+
});
|
|
76
124
|
describe("allOf", () => {
|
|
77
125
|
it("should render same-level properties with allOf", async () => {
|
|
78
126
|
const schema = {
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "docusaurus-plugin-openapi-docs",
|
|
3
3
|
"description": "OpenAPI plugin for Docusaurus.",
|
|
4
|
-
"version": "2.2.
|
|
4
|
+
"version": "2.2.4",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"keywords": [
|
|
7
7
|
"openapi",
|
|
@@ -60,5 +60,5 @@
|
|
|
60
60
|
"engines": {
|
|
61
61
|
"node": ">=14"
|
|
62
62
|
},
|
|
63
|
-
"gitHead": "
|
|
63
|
+
"gitHead": "92e149800434ede3b07c5a8b60129322944d2b57"
|
|
64
64
|
}
|
|
@@ -145,6 +145,825 @@ Array [
|
|
|
145
145
|
]
|
|
146
146
|
`;
|
|
147
147
|
|
|
148
|
+
exports[`createNodes anyOf should render oneOf within anyOf 1`] = `
|
|
149
|
+
Array [
|
|
150
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
151
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
152
|
+
<summary style={{}}>
|
|
153
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
154
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
155
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
156
|
+
</span>
|
|
157
|
+
</summary>
|
|
158
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
159
|
+
<div>
|
|
160
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
161
|
+
anyOf
|
|
162
|
+
</span>
|
|
163
|
+
<SchemaTabs>
|
|
164
|
+
<TabItem label={\\"An int or a bool\\"} value={\\"0-item-properties\\"}>
|
|
165
|
+
<div>
|
|
166
|
+
<span
|
|
167
|
+
className={\\"badge badge--info\\"}
|
|
168
|
+
style={{ marginBottom: \\"1rem\\" }}
|
|
169
|
+
>
|
|
170
|
+
oneOf
|
|
171
|
+
</span>
|
|
172
|
+
<SchemaTabs>
|
|
173
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
174
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
175
|
+
integer
|
|
176
|
+
</div>
|
|
177
|
+
</TabItem>
|
|
178
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
179
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
180
|
+
boolean
|
|
181
|
+
</div>
|
|
182
|
+
</TabItem>
|
|
183
|
+
</SchemaTabs>
|
|
184
|
+
</div>
|
|
185
|
+
</TabItem>
|
|
186
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
187
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
188
|
+
string
|
|
189
|
+
</div>
|
|
190
|
+
</TabItem>
|
|
191
|
+
</SchemaTabs>
|
|
192
|
+
</div>
|
|
193
|
+
</div>
|
|
194
|
+
</details>
|
|
195
|
+
</SchemaItem>;
|
|
196
|
+
",
|
|
197
|
+
]
|
|
198
|
+
`;
|
|
199
|
+
|
|
200
|
+
exports[`createNodes anyOf should render primitives within anyOf 1`] = `
|
|
201
|
+
Array [
|
|
202
|
+
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
203
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
204
|
+
<summary style={{}}>
|
|
205
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
206
|
+
<strong className={\\"openapi-schema__property\\"}>oneOfProperty</strong>
|
|
207
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
208
|
+
</span>
|
|
209
|
+
</summary>
|
|
210
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
211
|
+
<div>
|
|
212
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
213
|
+
anyOf
|
|
214
|
+
</span>
|
|
215
|
+
<SchemaTabs>
|
|
216
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
217
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
218
|
+
integer
|
|
219
|
+
</div>
|
|
220
|
+
</TabItem>
|
|
221
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
222
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
223
|
+
boolean
|
|
224
|
+
</div>
|
|
225
|
+
</TabItem>
|
|
226
|
+
</SchemaTabs>
|
|
227
|
+
</div>
|
|
228
|
+
</div>
|
|
229
|
+
</details>
|
|
230
|
+
</SchemaItem>;
|
|
231
|
+
",
|
|
232
|
+
]
|
|
233
|
+
`;
|
|
234
|
+
|
|
235
|
+
exports[`createNodes discriminator should handle basic discriminator with mapping 1`] = `
|
|
236
|
+
Array [
|
|
237
|
+
"<div>
|
|
238
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
239
|
+
oneOf
|
|
240
|
+
</span>
|
|
241
|
+
<SchemaTabs>
|
|
242
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
243
|
+
<SchemaItem
|
|
244
|
+
collapsible={false}
|
|
245
|
+
name={\\"type\\"}
|
|
246
|
+
required={true}
|
|
247
|
+
schemaName={\\"string\\"}
|
|
248
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
249
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
250
|
+
></SchemaItem>
|
|
251
|
+
<SchemaItem
|
|
252
|
+
collapsible={false}
|
|
253
|
+
name={\\"propA\\"}
|
|
254
|
+
required={false}
|
|
255
|
+
schemaName={\\"string\\"}
|
|
256
|
+
qualifierMessage={undefined}
|
|
257
|
+
schema={{ type: \\"string\\" }}
|
|
258
|
+
></SchemaItem>
|
|
259
|
+
</TabItem>
|
|
260
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
261
|
+
<SchemaItem
|
|
262
|
+
collapsible={false}
|
|
263
|
+
name={\\"type\\"}
|
|
264
|
+
required={true}
|
|
265
|
+
schemaName={\\"string\\"}
|
|
266
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
267
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
268
|
+
></SchemaItem>
|
|
269
|
+
<SchemaItem
|
|
270
|
+
collapsible={false}
|
|
271
|
+
name={\\"propB\\"}
|
|
272
|
+
required={false}
|
|
273
|
+
schemaName={\\"number\\"}
|
|
274
|
+
qualifierMessage={undefined}
|
|
275
|
+
schema={{ type: \\"number\\" }}
|
|
276
|
+
></SchemaItem>
|
|
277
|
+
</TabItem>
|
|
278
|
+
</SchemaTabs>
|
|
279
|
+
</div>;
|
|
280
|
+
",
|
|
281
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
282
|
+
<div>
|
|
283
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
284
|
+
<strong
|
|
285
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
286
|
+
>
|
|
287
|
+
type
|
|
288
|
+
</strong>
|
|
289
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
290
|
+
</span>
|
|
291
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
292
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
293
|
+
</div>
|
|
294
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
295
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
296
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
297
|
+
#/definitions/TypeA
|
|
298
|
+
</div>
|
|
299
|
+
</TabItem>
|
|
300
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
301
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
302
|
+
#/definitions/TypeB
|
|
303
|
+
</div>
|
|
304
|
+
</TabItem>
|
|
305
|
+
</DiscriminatorTabs>
|
|
306
|
+
</div>
|
|
307
|
+
</div>;
|
|
308
|
+
",
|
|
309
|
+
]
|
|
310
|
+
`;
|
|
311
|
+
|
|
312
|
+
exports[`createNodes discriminator should handle basic discriminator with oneOf 1`] = `
|
|
313
|
+
Array [
|
|
314
|
+
"<div>
|
|
315
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
316
|
+
oneOf
|
|
317
|
+
</span>
|
|
318
|
+
<SchemaTabs>
|
|
319
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
320
|
+
<SchemaItem
|
|
321
|
+
collapsible={false}
|
|
322
|
+
name={\\"type\\"}
|
|
323
|
+
required={true}
|
|
324
|
+
schemaName={\\"string\\"}
|
|
325
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
326
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
327
|
+
></SchemaItem>
|
|
328
|
+
<SchemaItem
|
|
329
|
+
collapsible={false}
|
|
330
|
+
name={\\"propA\\"}
|
|
331
|
+
required={false}
|
|
332
|
+
schemaName={\\"string\\"}
|
|
333
|
+
qualifierMessage={undefined}
|
|
334
|
+
schema={{ type: \\"string\\" }}
|
|
335
|
+
></SchemaItem>
|
|
336
|
+
</TabItem>
|
|
337
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
338
|
+
<SchemaItem
|
|
339
|
+
collapsible={false}
|
|
340
|
+
name={\\"type\\"}
|
|
341
|
+
required={true}
|
|
342
|
+
schemaName={\\"string\\"}
|
|
343
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
344
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
345
|
+
></SchemaItem>
|
|
346
|
+
<SchemaItem
|
|
347
|
+
collapsible={false}
|
|
348
|
+
name={\\"propB\\"}
|
|
349
|
+
required={false}
|
|
350
|
+
schemaName={\\"number\\"}
|
|
351
|
+
qualifierMessage={undefined}
|
|
352
|
+
schema={{ type: \\"number\\" }}
|
|
353
|
+
></SchemaItem>
|
|
354
|
+
</TabItem>
|
|
355
|
+
</SchemaTabs>
|
|
356
|
+
</div>;
|
|
357
|
+
",
|
|
358
|
+
"<SchemaItem
|
|
359
|
+
collapsible={false}
|
|
360
|
+
name={\\"type\\"}
|
|
361
|
+
required={false}
|
|
362
|
+
schemaName={\\"string\\"}
|
|
363
|
+
qualifierMessage={undefined}
|
|
364
|
+
schema={{ type: \\"string\\" }}
|
|
365
|
+
></SchemaItem>;
|
|
366
|
+
",
|
|
367
|
+
]
|
|
368
|
+
`;
|
|
369
|
+
|
|
370
|
+
exports[`createNodes discriminator should handle discriminator with additional properties 1`] = `
|
|
371
|
+
Array [
|
|
372
|
+
"<div>
|
|
373
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
374
|
+
oneOf
|
|
375
|
+
</span>
|
|
376
|
+
<SchemaTabs>
|
|
377
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
378
|
+
<SchemaItem
|
|
379
|
+
collapsible={false}
|
|
380
|
+
name={\\"type\\"}
|
|
381
|
+
required={true}
|
|
382
|
+
schemaName={\\"string\\"}
|
|
383
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
384
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
385
|
+
></SchemaItem>
|
|
386
|
+
<SchemaItem
|
|
387
|
+
collapsible={false}
|
|
388
|
+
name={\\"propA\\"}
|
|
389
|
+
required={false}
|
|
390
|
+
schemaName={\\"string\\"}
|
|
391
|
+
qualifierMessage={undefined}
|
|
392
|
+
schema={{ type: \\"string\\" }}
|
|
393
|
+
></SchemaItem>
|
|
394
|
+
</TabItem>
|
|
395
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
396
|
+
<SchemaItem
|
|
397
|
+
collapsible={false}
|
|
398
|
+
name={\\"type\\"}
|
|
399
|
+
required={true}
|
|
400
|
+
schemaName={\\"string\\"}
|
|
401
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
402
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
403
|
+
></SchemaItem>
|
|
404
|
+
<SchemaItem
|
|
405
|
+
collapsible={false}
|
|
406
|
+
name={\\"propB\\"}
|
|
407
|
+
required={false}
|
|
408
|
+
schemaName={\\"number\\"}
|
|
409
|
+
qualifierMessage={undefined}
|
|
410
|
+
schema={{ type: \\"number\\" }}
|
|
411
|
+
></SchemaItem>
|
|
412
|
+
</TabItem>
|
|
413
|
+
</SchemaTabs>
|
|
414
|
+
</div>;
|
|
415
|
+
",
|
|
416
|
+
"<SchemaItem
|
|
417
|
+
collapsible={false}
|
|
418
|
+
name={\\"type\\"}
|
|
419
|
+
required={false}
|
|
420
|
+
schemaName={\\"string\\"}
|
|
421
|
+
qualifierMessage={undefined}
|
|
422
|
+
schema={{ type: \\"string\\" }}
|
|
423
|
+
></SchemaItem>;
|
|
424
|
+
",
|
|
425
|
+
]
|
|
426
|
+
`;
|
|
427
|
+
|
|
428
|
+
exports[`createNodes discriminator should handle discriminator with allOf 1`] = `
|
|
429
|
+
Array [
|
|
430
|
+
"<SchemaItem
|
|
431
|
+
collapsible={false}
|
|
432
|
+
name={\\"type\\"}
|
|
433
|
+
required={false}
|
|
434
|
+
schemaName={\\"string\\"}
|
|
435
|
+
qualifierMessage={undefined}
|
|
436
|
+
schema={{ type: \\"string\\" }}
|
|
437
|
+
></SchemaItem>;
|
|
438
|
+
",
|
|
439
|
+
"<div>
|
|
440
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
441
|
+
oneOf
|
|
442
|
+
</span>
|
|
443
|
+
<SchemaTabs>
|
|
444
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
445
|
+
<SchemaItem
|
|
446
|
+
collapsible={false}
|
|
447
|
+
name={\\"type\\"}
|
|
448
|
+
required={true}
|
|
449
|
+
schemaName={\\"string\\"}
|
|
450
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
451
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
452
|
+
></SchemaItem>
|
|
453
|
+
<SchemaItem
|
|
454
|
+
collapsible={false}
|
|
455
|
+
name={\\"propA\\"}
|
|
456
|
+
required={false}
|
|
457
|
+
schemaName={\\"string\\"}
|
|
458
|
+
qualifierMessage={undefined}
|
|
459
|
+
schema={{ type: \\"string\\" }}
|
|
460
|
+
></SchemaItem>
|
|
461
|
+
</TabItem>
|
|
462
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
463
|
+
<SchemaItem
|
|
464
|
+
collapsible={false}
|
|
465
|
+
name={\\"type\\"}
|
|
466
|
+
required={true}
|
|
467
|
+
schemaName={\\"string\\"}
|
|
468
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
469
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
470
|
+
></SchemaItem>
|
|
471
|
+
<SchemaItem
|
|
472
|
+
collapsible={false}
|
|
473
|
+
name={\\"propB\\"}
|
|
474
|
+
required={false}
|
|
475
|
+
schemaName={\\"number\\"}
|
|
476
|
+
qualifierMessage={undefined}
|
|
477
|
+
schema={{ type: \\"number\\" }}
|
|
478
|
+
></SchemaItem>
|
|
479
|
+
</TabItem>
|
|
480
|
+
</SchemaTabs>
|
|
481
|
+
</div>;
|
|
482
|
+
",
|
|
483
|
+
"<SchemaItem
|
|
484
|
+
collapsible={false}
|
|
485
|
+
name={\\"sharedProp\\"}
|
|
486
|
+
required={false}
|
|
487
|
+
schemaName={\\"string\\"}
|
|
488
|
+
qualifierMessage={undefined}
|
|
489
|
+
schema={{ type: \\"string\\" }}
|
|
490
|
+
></SchemaItem>;
|
|
491
|
+
",
|
|
492
|
+
]
|
|
493
|
+
`;
|
|
494
|
+
|
|
495
|
+
exports[`createNodes discriminator should handle discriminator with allOf and mapping 1`] = `
|
|
496
|
+
Array [
|
|
497
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
498
|
+
<div>
|
|
499
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
500
|
+
<strong
|
|
501
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
502
|
+
>
|
|
503
|
+
type
|
|
504
|
+
</strong>
|
|
505
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
506
|
+
</span>
|
|
507
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
508
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
509
|
+
</div>
|
|
510
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
511
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
512
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
513
|
+
#/definitions/TypeA
|
|
514
|
+
</div>
|
|
515
|
+
</TabItem>
|
|
516
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
517
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
518
|
+
#/definitions/TypeB
|
|
519
|
+
</div>
|
|
520
|
+
</TabItem>
|
|
521
|
+
</DiscriminatorTabs>
|
|
522
|
+
</div>
|
|
523
|
+
</div>;
|
|
524
|
+
",
|
|
525
|
+
"<div>
|
|
526
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
527
|
+
oneOf
|
|
528
|
+
</span>
|
|
529
|
+
<SchemaTabs>
|
|
530
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
531
|
+
<SchemaItem
|
|
532
|
+
collapsible={false}
|
|
533
|
+
name={\\"type\\"}
|
|
534
|
+
required={true}
|
|
535
|
+
schemaName={\\"string\\"}
|
|
536
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
537
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
538
|
+
></SchemaItem>
|
|
539
|
+
<SchemaItem
|
|
540
|
+
collapsible={false}
|
|
541
|
+
name={\\"propA\\"}
|
|
542
|
+
required={false}
|
|
543
|
+
schemaName={\\"string\\"}
|
|
544
|
+
qualifierMessage={undefined}
|
|
545
|
+
schema={{ type: \\"string\\" }}
|
|
546
|
+
></SchemaItem>
|
|
547
|
+
</TabItem>
|
|
548
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
549
|
+
<SchemaItem
|
|
550
|
+
collapsible={false}
|
|
551
|
+
name={\\"type\\"}
|
|
552
|
+
required={true}
|
|
553
|
+
schemaName={\\"string\\"}
|
|
554
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
555
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
556
|
+
></SchemaItem>
|
|
557
|
+
<SchemaItem
|
|
558
|
+
collapsible={false}
|
|
559
|
+
name={\\"propB\\"}
|
|
560
|
+
required={false}
|
|
561
|
+
schemaName={\\"number\\"}
|
|
562
|
+
qualifierMessage={undefined}
|
|
563
|
+
schema={{ type: \\"number\\" }}
|
|
564
|
+
></SchemaItem>
|
|
565
|
+
</TabItem>
|
|
566
|
+
</SchemaTabs>
|
|
567
|
+
</div>;
|
|
568
|
+
",
|
|
569
|
+
"<SchemaItem
|
|
570
|
+
collapsible={false}
|
|
571
|
+
name={\\"sharedProp\\"}
|
|
572
|
+
required={false}
|
|
573
|
+
schemaName={\\"string\\"}
|
|
574
|
+
qualifierMessage={undefined}
|
|
575
|
+
schema={{ type: \\"string\\" }}
|
|
576
|
+
></SchemaItem>;
|
|
577
|
+
",
|
|
578
|
+
]
|
|
579
|
+
`;
|
|
580
|
+
|
|
581
|
+
exports[`createNodes discriminator should handle discriminator with nested schemas 1`] = `
|
|
582
|
+
Array [
|
|
583
|
+
"<div>
|
|
584
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
585
|
+
oneOf
|
|
586
|
+
</span>
|
|
587
|
+
<SchemaTabs>
|
|
588
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
589
|
+
<SchemaItem
|
|
590
|
+
collapsible={false}
|
|
591
|
+
name={\\"type\\"}
|
|
592
|
+
required={true}
|
|
593
|
+
schemaName={\\"string\\"}
|
|
594
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
595
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
596
|
+
></SchemaItem>
|
|
597
|
+
<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
598
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
599
|
+
<summary style={{}}>
|
|
600
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
601
|
+
<strong className={\\"openapi-schema__property\\"}>nestedA</strong>
|
|
602
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
603
|
+
</span>
|
|
604
|
+
</summary>
|
|
605
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
606
|
+
<SchemaItem
|
|
607
|
+
collapsible={false}
|
|
608
|
+
name={\\"propA1\\"}
|
|
609
|
+
required={false}
|
|
610
|
+
schemaName={\\"string\\"}
|
|
611
|
+
qualifierMessage={undefined}
|
|
612
|
+
schema={{ type: \\"string\\" }}
|
|
613
|
+
></SchemaItem>
|
|
614
|
+
<SchemaItem
|
|
615
|
+
collapsible={false}
|
|
616
|
+
name={\\"propA2\\"}
|
|
617
|
+
required={false}
|
|
618
|
+
schemaName={\\"number\\"}
|
|
619
|
+
qualifierMessage={undefined}
|
|
620
|
+
schema={{ type: \\"number\\" }}
|
|
621
|
+
></SchemaItem>
|
|
622
|
+
</div>
|
|
623
|
+
</details>
|
|
624
|
+
</SchemaItem>
|
|
625
|
+
</TabItem>
|
|
626
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
627
|
+
<SchemaItem
|
|
628
|
+
collapsible={false}
|
|
629
|
+
name={\\"type\\"}
|
|
630
|
+
required={true}
|
|
631
|
+
schemaName={\\"string\\"}
|
|
632
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
633
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
634
|
+
></SchemaItem>
|
|
635
|
+
<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
636
|
+
<details style={{}} className={\\"openapi-markdown__details\\"}>
|
|
637
|
+
<summary style={{}}>
|
|
638
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
639
|
+
<strong className={\\"openapi-schema__property\\"}>nestedB</strong>
|
|
640
|
+
<span className={\\"openapi-schema__name\\"}>object</span>
|
|
641
|
+
</span>
|
|
642
|
+
</summary>
|
|
643
|
+
<div style={{ marginLeft: \\"1rem\\" }}>
|
|
644
|
+
<SchemaItem
|
|
645
|
+
collapsible={false}
|
|
646
|
+
name={\\"propB1\\"}
|
|
647
|
+
required={false}
|
|
648
|
+
schemaName={\\"string\\"}
|
|
649
|
+
qualifierMessage={undefined}
|
|
650
|
+
schema={{ type: \\"string\\" }}
|
|
651
|
+
></SchemaItem>
|
|
652
|
+
<SchemaItem
|
|
653
|
+
collapsible={false}
|
|
654
|
+
name={\\"propB2\\"}
|
|
655
|
+
required={false}
|
|
656
|
+
schemaName={\\"boolean\\"}
|
|
657
|
+
qualifierMessage={undefined}
|
|
658
|
+
schema={{ type: \\"boolean\\" }}
|
|
659
|
+
></SchemaItem>
|
|
660
|
+
</div>
|
|
661
|
+
</details>
|
|
662
|
+
</SchemaItem>
|
|
663
|
+
</TabItem>
|
|
664
|
+
</SchemaTabs>
|
|
665
|
+
</div>;
|
|
666
|
+
",
|
|
667
|
+
"<SchemaItem
|
|
668
|
+
collapsible={false}
|
|
669
|
+
name={\\"type\\"}
|
|
670
|
+
required={false}
|
|
671
|
+
schemaName={\\"string\\"}
|
|
672
|
+
qualifierMessage={undefined}
|
|
673
|
+
schema={{ type: \\"string\\" }}
|
|
674
|
+
></SchemaItem>;
|
|
675
|
+
",
|
|
676
|
+
]
|
|
677
|
+
`;
|
|
678
|
+
|
|
679
|
+
exports[`createNodes discriminator should handle discriminator with required properties 1`] = `
|
|
680
|
+
Array [
|
|
681
|
+
"<div>
|
|
682
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
683
|
+
oneOf
|
|
684
|
+
</span>
|
|
685
|
+
<SchemaTabs>
|
|
686
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
687
|
+
<SchemaItem
|
|
688
|
+
collapsible={false}
|
|
689
|
+
name={\\"type\\"}
|
|
690
|
+
required={true}
|
|
691
|
+
schemaName={\\"string\\"}
|
|
692
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
693
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
694
|
+
></SchemaItem>
|
|
695
|
+
<SchemaItem
|
|
696
|
+
collapsible={false}
|
|
697
|
+
name={\\"propA\\"}
|
|
698
|
+
required={true}
|
|
699
|
+
schemaName={\\"string\\"}
|
|
700
|
+
qualifierMessage={undefined}
|
|
701
|
+
schema={{ type: \\"string\\" }}
|
|
702
|
+
></SchemaItem>
|
|
703
|
+
</TabItem>
|
|
704
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
705
|
+
<SchemaItem
|
|
706
|
+
collapsible={false}
|
|
707
|
+
name={\\"type\\"}
|
|
708
|
+
required={true}
|
|
709
|
+
schemaName={\\"string\\"}
|
|
710
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
711
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
712
|
+
></SchemaItem>
|
|
713
|
+
<SchemaItem
|
|
714
|
+
collapsible={false}
|
|
715
|
+
name={\\"propB\\"}
|
|
716
|
+
required={true}
|
|
717
|
+
schemaName={\\"number\\"}
|
|
718
|
+
qualifierMessage={undefined}
|
|
719
|
+
schema={{ type: \\"number\\" }}
|
|
720
|
+
></SchemaItem>
|
|
721
|
+
</TabItem>
|
|
722
|
+
</SchemaTabs>
|
|
723
|
+
</div>;
|
|
724
|
+
",
|
|
725
|
+
"<SchemaItem
|
|
726
|
+
collapsible={false}
|
|
727
|
+
name={\\"type\\"}
|
|
728
|
+
required={false}
|
|
729
|
+
schemaName={\\"string\\"}
|
|
730
|
+
qualifierMessage={undefined}
|
|
731
|
+
schema={{ type: \\"string\\" }}
|
|
732
|
+
></SchemaItem>;
|
|
733
|
+
",
|
|
734
|
+
]
|
|
735
|
+
`;
|
|
736
|
+
|
|
737
|
+
exports[`createNodes discriminator should handle discriminator with required properties and mapping 1`] = `
|
|
738
|
+
Array [
|
|
739
|
+
"<div>
|
|
740
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
741
|
+
oneOf
|
|
742
|
+
</span>
|
|
743
|
+
<SchemaTabs>
|
|
744
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
745
|
+
<SchemaItem
|
|
746
|
+
collapsible={false}
|
|
747
|
+
name={\\"type\\"}
|
|
748
|
+
required={true}
|
|
749
|
+
schemaName={\\"string\\"}
|
|
750
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
751
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
752
|
+
></SchemaItem>
|
|
753
|
+
<SchemaItem
|
|
754
|
+
collapsible={false}
|
|
755
|
+
name={\\"propA\\"}
|
|
756
|
+
required={true}
|
|
757
|
+
schemaName={\\"string\\"}
|
|
758
|
+
qualifierMessage={undefined}
|
|
759
|
+
schema={{ type: \\"string\\" }}
|
|
760
|
+
></SchemaItem>
|
|
761
|
+
</TabItem>
|
|
762
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
763
|
+
<SchemaItem
|
|
764
|
+
collapsible={false}
|
|
765
|
+
name={\\"type\\"}
|
|
766
|
+
required={true}
|
|
767
|
+
schemaName={\\"string\\"}
|
|
768
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
769
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
770
|
+
></SchemaItem>
|
|
771
|
+
<SchemaItem
|
|
772
|
+
collapsible={false}
|
|
773
|
+
name={\\"propB\\"}
|
|
774
|
+
required={true}
|
|
775
|
+
schemaName={\\"number\\"}
|
|
776
|
+
qualifierMessage={undefined}
|
|
777
|
+
schema={{ type: \\"number\\" }}
|
|
778
|
+
></SchemaItem>
|
|
779
|
+
</TabItem>
|
|
780
|
+
</SchemaTabs>
|
|
781
|
+
</div>;
|
|
782
|
+
",
|
|
783
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
784
|
+
<div>
|
|
785
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
786
|
+
<strong
|
|
787
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
788
|
+
>
|
|
789
|
+
type
|
|
790
|
+
</strong>
|
|
791
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
792
|
+
</span>
|
|
793
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
794
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
795
|
+
</div>
|
|
796
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
797
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
798
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
799
|
+
#/definitions/TypeA
|
|
800
|
+
</div>
|
|
801
|
+
</TabItem>
|
|
802
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
803
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
804
|
+
#/definitions/TypeB
|
|
805
|
+
</div>
|
|
806
|
+
</TabItem>
|
|
807
|
+
</DiscriminatorTabs>
|
|
808
|
+
</div>
|
|
809
|
+
</div>;
|
|
810
|
+
",
|
|
811
|
+
]
|
|
812
|
+
`;
|
|
813
|
+
|
|
814
|
+
exports[`createNodes discriminator should handle discriminator with shared properties 1`] = `
|
|
815
|
+
Array [
|
|
816
|
+
"<div>
|
|
817
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
818
|
+
oneOf
|
|
819
|
+
</span>
|
|
820
|
+
<SchemaTabs>
|
|
821
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
822
|
+
<SchemaItem
|
|
823
|
+
collapsible={false}
|
|
824
|
+
name={\\"type\\"}
|
|
825
|
+
required={true}
|
|
826
|
+
schemaName={\\"string\\"}
|
|
827
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
828
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
829
|
+
></SchemaItem>
|
|
830
|
+
<SchemaItem
|
|
831
|
+
collapsible={false}
|
|
832
|
+
name={\\"propA\\"}
|
|
833
|
+
required={false}
|
|
834
|
+
schemaName={\\"string\\"}
|
|
835
|
+
qualifierMessage={undefined}
|
|
836
|
+
schema={{ type: \\"string\\" }}
|
|
837
|
+
></SchemaItem>
|
|
838
|
+
</TabItem>
|
|
839
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
840
|
+
<SchemaItem
|
|
841
|
+
collapsible={false}
|
|
842
|
+
name={\\"type\\"}
|
|
843
|
+
required={true}
|
|
844
|
+
schemaName={\\"string\\"}
|
|
845
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
846
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
847
|
+
></SchemaItem>
|
|
848
|
+
<SchemaItem
|
|
849
|
+
collapsible={false}
|
|
850
|
+
name={\\"propB\\"}
|
|
851
|
+
required={false}
|
|
852
|
+
schemaName={\\"number\\"}
|
|
853
|
+
qualifierMessage={undefined}
|
|
854
|
+
schema={{ type: \\"number\\" }}
|
|
855
|
+
></SchemaItem>
|
|
856
|
+
</TabItem>
|
|
857
|
+
</SchemaTabs>
|
|
858
|
+
</div>;
|
|
859
|
+
",
|
|
860
|
+
"<SchemaItem
|
|
861
|
+
collapsible={false}
|
|
862
|
+
name={\\"type\\"}
|
|
863
|
+
required={false}
|
|
864
|
+
schemaName={\\"string\\"}
|
|
865
|
+
qualifierMessage={undefined}
|
|
866
|
+
schema={{ type: \\"string\\" }}
|
|
867
|
+
></SchemaItem>;
|
|
868
|
+
",
|
|
869
|
+
"<SchemaItem
|
|
870
|
+
collapsible={false}
|
|
871
|
+
name={\\"sharedProp\\"}
|
|
872
|
+
required={false}
|
|
873
|
+
schemaName={\\"string\\"}
|
|
874
|
+
qualifierMessage={undefined}
|
|
875
|
+
schema={{ type: \\"string\\" }}
|
|
876
|
+
></SchemaItem>;
|
|
877
|
+
",
|
|
878
|
+
]
|
|
879
|
+
`;
|
|
880
|
+
|
|
881
|
+
exports[`createNodes discriminator should handle discriminator with shared properties and mapping 1`] = `
|
|
882
|
+
Array [
|
|
883
|
+
"<div>
|
|
884
|
+
<span className={\\"badge badge--info\\"} style={{ marginBottom: \\"1rem\\" }}>
|
|
885
|
+
oneOf
|
|
886
|
+
</span>
|
|
887
|
+
<SchemaTabs>
|
|
888
|
+
<TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
|
|
889
|
+
<SchemaItem
|
|
890
|
+
collapsible={false}
|
|
891
|
+
name={\\"type\\"}
|
|
892
|
+
required={true}
|
|
893
|
+
schemaName={\\"string\\"}
|
|
894
|
+
qualifierMessage={\\"**Possible values:** [\`typeA\`]\\"}
|
|
895
|
+
schema={{ type: \\"string\\", enum: [\\"typeA\\"] }}
|
|
896
|
+
></SchemaItem>
|
|
897
|
+
<SchemaItem
|
|
898
|
+
collapsible={false}
|
|
899
|
+
name={\\"propA\\"}
|
|
900
|
+
required={false}
|
|
901
|
+
schemaName={\\"string\\"}
|
|
902
|
+
qualifierMessage={undefined}
|
|
903
|
+
schema={{ type: \\"string\\" }}
|
|
904
|
+
></SchemaItem>
|
|
905
|
+
</TabItem>
|
|
906
|
+
<TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
|
|
907
|
+
<SchemaItem
|
|
908
|
+
collapsible={false}
|
|
909
|
+
name={\\"type\\"}
|
|
910
|
+
required={true}
|
|
911
|
+
schemaName={\\"string\\"}
|
|
912
|
+
qualifierMessage={\\"**Possible values:** [\`typeB\`]\\"}
|
|
913
|
+
schema={{ type: \\"string\\", enum: [\\"typeB\\"] }}
|
|
914
|
+
></SchemaItem>
|
|
915
|
+
<SchemaItem
|
|
916
|
+
collapsible={false}
|
|
917
|
+
name={\\"propB\\"}
|
|
918
|
+
required={false}
|
|
919
|
+
schemaName={\\"number\\"}
|
|
920
|
+
qualifierMessage={undefined}
|
|
921
|
+
schema={{ type: \\"number\\" }}
|
|
922
|
+
></SchemaItem>
|
|
923
|
+
</TabItem>
|
|
924
|
+
</SchemaTabs>
|
|
925
|
+
</div>;
|
|
926
|
+
",
|
|
927
|
+
"<div className={\\"openapi-discriminator__item openapi-schema__list-item\\"}>
|
|
928
|
+
<div>
|
|
929
|
+
<span className={\\"openapi-schema__container\\"}>
|
|
930
|
+
<strong
|
|
931
|
+
className={\\"openapi-discriminator__name openapi-schema__property\\"}
|
|
932
|
+
>
|
|
933
|
+
type
|
|
934
|
+
</strong>
|
|
935
|
+
<span className={\\"openapi-schema__name\\"}>string</span>
|
|
936
|
+
</span>
|
|
937
|
+
<div style={{ paddingLeft: \\"1rem\\" }}>
|
|
938
|
+
**Possible values:** [\`typeA\`, \`typeB\`]
|
|
939
|
+
</div>
|
|
940
|
+
<DiscriminatorTabs className={\\"openapi-tabs__discriminator\\"}>
|
|
941
|
+
<TabItem label={\\"typeA\\"} value={\\"0-item-discriminator\\"}>
|
|
942
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
943
|
+
#/definitions/TypeA
|
|
944
|
+
</div>
|
|
945
|
+
</TabItem>
|
|
946
|
+
<TabItem label={\\"typeB\\"} value={\\"1-item-discriminator\\"}>
|
|
947
|
+
<div style={{ marginTop: \\".5rem\\", marginBottom: \\".5rem\\" }}>
|
|
948
|
+
#/definitions/TypeB
|
|
949
|
+
</div>
|
|
950
|
+
</TabItem>
|
|
951
|
+
</DiscriminatorTabs>
|
|
952
|
+
</div>
|
|
953
|
+
</div>;
|
|
954
|
+
",
|
|
955
|
+
"<SchemaItem
|
|
956
|
+
collapsible={false}
|
|
957
|
+
name={\\"sharedProp\\"}
|
|
958
|
+
required={false}
|
|
959
|
+
schemaName={\\"string\\"}
|
|
960
|
+
qualifierMessage={undefined}
|
|
961
|
+
schema={{ type: \\"string\\" }}
|
|
962
|
+
></SchemaItem>;
|
|
963
|
+
",
|
|
964
|
+
]
|
|
965
|
+
`;
|
|
966
|
+
|
|
148
967
|
exports[`createNodes oneOf should create readable MODs for oneOf primitive properties 1`] = `
|
|
149
968
|
Array [
|
|
150
969
|
"<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
|
|
@@ -59,6 +59,70 @@ describe("createNodes", () => {
|
|
|
59
59
|
});
|
|
60
60
|
});
|
|
61
61
|
|
|
62
|
+
describe("anyOf", () => {
|
|
63
|
+
it("should render primitives within anyOf", async () => {
|
|
64
|
+
const schema: SchemaObject = {
|
|
65
|
+
type: "object",
|
|
66
|
+
properties: {
|
|
67
|
+
oneOfProperty: {
|
|
68
|
+
anyOf: [
|
|
69
|
+
{
|
|
70
|
+
type: "integer",
|
|
71
|
+
},
|
|
72
|
+
{
|
|
73
|
+
type: "boolean",
|
|
74
|
+
},
|
|
75
|
+
],
|
|
76
|
+
title: "One of int or bool",
|
|
77
|
+
},
|
|
78
|
+
},
|
|
79
|
+
};
|
|
80
|
+
|
|
81
|
+
expect(
|
|
82
|
+
await Promise.all(
|
|
83
|
+
createNodes(schema, "response").map(
|
|
84
|
+
async (md: any) => await prettier.format(md, { parser: "babel" })
|
|
85
|
+
)
|
|
86
|
+
)
|
|
87
|
+
).toMatchSnapshot();
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
it("should render oneOf within anyOf", async () => {
|
|
91
|
+
const schema: SchemaObject = {
|
|
92
|
+
type: "object",
|
|
93
|
+
properties: {
|
|
94
|
+
oneOfProperty: {
|
|
95
|
+
anyOf: [
|
|
96
|
+
{
|
|
97
|
+
oneOf: [
|
|
98
|
+
{
|
|
99
|
+
type: "integer",
|
|
100
|
+
},
|
|
101
|
+
{
|
|
102
|
+
type: "boolean",
|
|
103
|
+
},
|
|
104
|
+
],
|
|
105
|
+
title: "An int or a bool",
|
|
106
|
+
},
|
|
107
|
+
{
|
|
108
|
+
type: "string",
|
|
109
|
+
},
|
|
110
|
+
],
|
|
111
|
+
title: "One of int or bool, or a string",
|
|
112
|
+
},
|
|
113
|
+
},
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
expect(
|
|
117
|
+
await Promise.all(
|
|
118
|
+
createNodes(schema, "response").map(
|
|
119
|
+
async (md: any) => await prettier.format(md, { parser: "babel" })
|
|
120
|
+
)
|
|
121
|
+
)
|
|
122
|
+
).toMatchSnapshot();
|
|
123
|
+
});
|
|
124
|
+
});
|
|
125
|
+
|
|
62
126
|
describe("allOf", () => {
|
|
63
127
|
it("should render same-level properties with allOf", async () => {
|
|
64
128
|
const schema: SchemaObject = {
|
|
@@ -92,6 +92,11 @@ function createAnyOneOf(schema: SchemaObject): any {
|
|
|
92
92
|
delete anyOneSchema.allOf;
|
|
93
93
|
}
|
|
94
94
|
|
|
95
|
+
if (anyOneSchema.oneOf !== undefined) {
|
|
96
|
+
anyOneChildren.push(createNodes(anyOneSchema, SCHEMA_TYPE));
|
|
97
|
+
delete anyOneSchema.oneOf;
|
|
98
|
+
}
|
|
99
|
+
|
|
95
100
|
if (anyOneSchema.items !== undefined) {
|
|
96
101
|
anyOneChildren.push(createItems(anyOneSchema));
|
|
97
102
|
delete anyOneSchema.items;
|
|
@@ -535,8 +540,9 @@ function createPropertyDiscriminator(
|
|
|
535
540
|
return undefined;
|
|
536
541
|
}
|
|
537
542
|
|
|
543
|
+
// render as a simple property if there's no mapping
|
|
538
544
|
if (discriminator.mapping === undefined) {
|
|
539
|
-
return
|
|
545
|
+
return createEdges({ name, schema, required });
|
|
540
546
|
}
|
|
541
547
|
|
|
542
548
|
return create("div", {
|