1798

pending completion

Build # 1798

Build Type

Pull #1381

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/Redocly/redoc/commit/<a class=hub.com/Redocly/redoc/commit/<a class="double-link" href="https://git"><a class=hub.com/Redocly/redoc/commit/<a class="double-link" href="https://git"><a class=hub.com/Redocly/redoc/commit/<a class="double-link" href="https://git"><a class=hub.com/Redocly/redoc/commit/1159c5bacff2f3858fb6d3cd180b699c23bdea07">1159c5bac">&lt;a href=&quot;https://github.com/Redocly/redoc/commit/</a><a class="double-link" href="https://github.com/Redocly/redoc/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Redocly/redoc/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Redocly/redoc/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Redocly/redoc/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Redocly/redoc/commit/1159c5bacff2f3858fb6d3cd180b699c23bdea07">1159c5bac</a><a href="https://github.com/Redocly/redoc/commit/1159c5bacff2f3858fb6d3cd180b699c23bdea07">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Redocly/redoc/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Redocly/redoc/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Redocly/redoc/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Redocly/redoc/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Redocly/redoc/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Redocly/redoc/commit/1159c5bacff2f3858fb6d3cd180b699c23bdea07&quot;&gt;1159c5bac&lt;/a&gt;&lt;a href=&quot;https://github.com/Redocly/redoc/commit/1159c5bacff2f3858fb6d3cd180b699c23bdea07&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Redocly/redoc/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/Redocly/redoc/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #1381: feat: add support for x-description to override description of resolved

Run Details

1573 of 2310 branches covered (68.1%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

3195 of 3948 relevant lines covered (80.93%)

126.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.23

/src/services/OpenAPIParser.ts

import { resolve as urlResolve } from 'url';

import { OpenAPIRef, OpenAPISchema, OpenAPISpec, Referenced } from '../types';

import { appendToMdHeading, IS_BROWSER } from '../utils/';
import { JsonPointer } from '../utils/JsonPointer';
import {
  isNamedDefinition,
  SECURITY_DEFINITIONS_COMPONENT_NAME,
  SECURITY_DEFINITIONS_JSX_NAME,
} from '../utils/openapi';
import { buildComponentComment, MarkdownRenderer } from './MarkdownRenderer';
import { RedocNormalizedOptions } from './RedocNormalizedOptions';

export type MergedOpenAPISchema = OpenAPISchema & { parentRefs?: string[] };

/**
 * Helper class to keep track of visited references to avoid
 * endless recursion because of circular refs
 */
class RefCounter {
  _counter = {};

  reset(): void {
    this._counter = {};
  }

  visit(ref: string): void {
    this._counter[ref] = this._counter[ref] ? this._counter[ref] + 1 : 1;
  }

  exit(ref: string): void {
    this._counter[ref] = this._counter[ref] && this._counter[ref] - 1;
  }

  visited(ref: string): boolean {
    return !!this._counter[ref];
  }
}

/**
 * Loads and keeps spec. Provides raw spec operations
 */
export class OpenAPIParser {
  specUrl?: string;
  spec: OpenAPISpec;
  mergeRefs: Set<string>;

  private _refCounter: RefCounter = new RefCounter();

  constructor(
    spec: OpenAPISpec,
    specUrl?: string,
    private options: RedocNormalizedOptions = new RedocNormalizedOptions({}),
  ) {
    this.validate(spec);
    this.preprocess(spec);

    this.spec = spec;

    this.mergeRefs = new Set();

    const href = IS_BROWSER ? window.location.href : '';
    if (typeof specUrl === 'string') {
      this.specUrl = urlResolve(href, specUrl);
    }
  }

  validate(spec: any) {
    if (spec.openapi === undefined) {
      throw new Error('Document must be valid OpenAPI 3.0.0 definition');
    }
  }

  preprocess(spec: OpenAPISpec) {
    if (
      !this.options.noAutoAuth &&
      spec.info &&
      spec.components &&
      spec.components.securitySchemes
    ) {
      // Automatically inject Authentication section with SecurityDefinitions component
      const description = spec.info.description || '';
      if (
        !MarkdownRenderer.containsComponent(description, SECURITY_DEFINITIONS_COMPONENT_NAME) &&
        !MarkdownRenderer.containsComponent(description, SECURITY_DEFINITIONS_JSX_NAME)
      ) {
        const comment = buildComponentComment(SECURITY_DEFINITIONS_COMPONENT_NAME);
        spec.info.description = appendToMdHeading(description, 'Authentication', comment);
      }
    }
  }

  /**
   * get spec part by JsonPointer ($ref)
   */
  byRef = <T extends any = any>(ref: string): T | undefined => {
    let res;
    if (!this.spec) {
      return;
    }
    if (ref.charAt(0) !== '#') {
      ref = '#' + ref;
    }
    ref = decodeURIComponent(ref);
    try {
      res = JsonPointer.get(this.spec, ref);
    } catch (e) {
      // do nothing
    }
    return res || {};
  };

  /**
   * checks if the object is OpenAPI reference (contains $ref property)
   */
  isRef(obj: any): obj is OpenAPIRef {
    if (!obj) {
      return false;
    }
    return obj.$ref !== undefined && obj.$ref !== null;
  }

  /**
   * resets visited endpoints. should be run after
   */
  resetVisited() {
    if (process.env.NODE_ENV !== 'production') {
      // check in dev mode
      for (const k in this._refCounter._counter) {
        if (this._refCounter._counter[k] > 0) {
          console.warn('Not exited reference: ' + k);
        }
      }
    }
    this._refCounter = new RefCounter();
  }

  exitRef<T>(ref: Referenced<T>) {
    if (!this.isRef(ref)) {
      return;
    }
    this._refCounter.exit(ref.$ref);
  }

  /**
   * Resolve given reference object or return as is if it is not a reference
   * @param obj object to dereference
   * @param forceCircular whether to dereference even if it is circular ref
   */
  deref<T extends object>(obj: OpenAPIRef | T, forceCircular = false): T {
    if (this.isRef(obj)) {
      const resolved = this.byRef<T>(obj.$ref)!;
      const visited = this._refCounter.visited(obj.$ref);
      this._refCounter.visit(obj.$ref);
      if (visited && !forceCircular) {
        // circular reference detected
        // tslint:disable-next-line
        return Object.assign({}, resolved, { 'x-circular-ref': true });
      }
      // deref again in case one more $ref is here
      if (this.isRef(resolved)) {
        const res = this.deref(resolved);
        this.exitRef(resolved);
        return res;
      }
      if (obj['x-description']) {
        return Object.assign({}, resolved, { description: obj['x-description'] });
      }
      return resolved;
    }
    return obj;
  }

  shalowDeref<T extends object>(obj: OpenAPIRef | T): T {
    if (this.isRef(obj)) {
      return this.byRef<T>(obj.$ref)!;
    }
    return obj;
  }

  /**
   * Merge allOf constraints.
   * @param schema schema with allOF
   * @param $ref pointer of the schema
   * @param forceCircular whether to dereference children even if it is a circular ref
   */
  mergeAllOf(
    schema: OpenAPISchema,
    $ref?: string,
    forceCircular: boolean = false,
    used$Refs = new Set<string>(),
  ): MergedOpenAPISchema {
    if ($ref) {
      used$Refs.add($ref);
    }

    schema = this.hoistOneOfs(schema);

    if (schema.allOf === undefined) {
      return schema;
    }

    let receiver: MergedOpenAPISchema = {
      ...schema,
      allOf: undefined,
      parentRefs: [],
      title: schema.title || (isNamedDefinition($ref) ? JsonPointer.baseName($ref) : undefined),
    };

    // avoid mutating inner objects
    if (receiver.properties !== undefined && typeof receiver.properties === 'object') {
      receiver.properties = { ...receiver.properties };
    }
    if (receiver.items !== undefined && typeof receiver.items === 'object') {
      receiver.items = { ...receiver.items };
    }

    const allOfSchemas = schema.allOf
      .map(subSchema => {
        if (subSchema && subSchema.$ref && used$Refs.has(subSchema.$ref)) {
          return undefined;
        }

        const resolved = this.deref(subSchema, forceCircular);
        const subRef = subSchema.$ref || undefined;
        const subMerged = this.mergeAllOf(resolved, subRef, forceCircular, used$Refs);
        receiver.parentRefs!.push(...(subMerged.parentRefs || []));
        return {
          $ref: subRef,
          schema: subMerged,
        };
      })
      .filter(child => child !== undefined) as Array<{
        $ref: string | undefined;
        schema: MergedOpenAPISchema;
      }>;

    for (const { $ref: subSchemaRef, schema: subSchema } of allOfSchemas) {
      if (
        receiver.type !== subSchema.type &&
        receiver.type !== undefined &&
        subSchema.type !== undefined
      ) {
        console.warn(
          `Incompatible types in allOf at "${$ref}": "${receiver.type}" and "${subSchema.type}"`,
        );
      }

      if (subSchema.type !== undefined) {
        receiver.type = subSchema.type;
      }

      if (subSchema.properties !== undefined) {
        receiver.properties = receiver.properties || {};
        for (const prop in subSchema.properties) {
          if (!receiver.properties[prop]) {
            receiver.properties[prop] = subSchema.properties[prop];
          } else {
            // merge inner properties
            receiver.properties[prop] = this.mergeAllOf(
              { allOf: [receiver.properties[prop], subSchema.properties[prop]] },
              $ref + '/properties/' + prop,
            );
          }
        }
      }

      if (subSchema.items !== undefined) {
        receiver.items = receiver.items || {};
        // merge inner properties
        receiver.items = this.mergeAllOf(
          { allOf: [receiver.items, subSchema.items] },
          $ref + '/items',
        );
      }

      if (subSchema.required !== undefined) {
        receiver.required = (receiver.required || []).concat(subSchema.required);
      }

      // merge rest of constraints
      // TODO: do more intelligent merge
      receiver = { ...subSchema, ...receiver };

      if (subSchemaRef) {
        receiver.parentRefs!.push(subSchemaRef);
        if (receiver.title === undefined && isNamedDefinition(subSchemaRef)) {
          // this is not so correct behaviour. commented out for now
          // ref: https://github.com/Redocly/redoc/issues/601
          // receiver.title = JsonPointer.baseName(subSchemaRef);
        }
      }
    }

    return receiver;
  }

  /**
   * Find all derived definitions among #/components/schemas from any of $refs
   * returns map of definition pointer to definition name
   * @param $refs array of references to find derived from
   */
  findDerived($refs: string[]): Record<string, string[] | string> {
    const res: Record<string, string[]> = {};
    const schemas = (this.spec.components && this.spec.components.schemas) || {};
    for (const defName in schemas) {
      const def = this.deref(schemas[defName]);
      if (
        def.allOf !== undefined &&
        def.allOf.find(obj => obj.$ref !== undefined && $refs.indexOf(obj.$ref) > -1)
      ) {
        res['#/components/schemas/' + defName] = [def['x-discriminator-value'] || defName];
      }
    }
    return res;
  }

  exitParents(shema: MergedOpenAPISchema) {
    for (const parent$ref of shema.parentRefs || []) {
      this.exitRef({ $ref: parent$ref });
    }
  }

  private hoistOneOfs(schema: OpenAPISchema) {
    if (schema.allOf === undefined) {
      return schema;
    }

    const allOf = schema.allOf;
    for (let i = 0; i < allOf.length; i++) {
      const sub = allOf[i];
      if (Array.isArray(sub.oneOf)) {
        const beforeAllOf = allOf.slice(0, i);
        const afterAllOf = allOf.slice(i + 1);
        return {
          oneOf: sub.oneOf.map(part => {
            const merged = this.mergeAllOf({
              allOf: [...beforeAllOf, part, ...afterAllOf],
            });

            // each oneOf should be independent so exiting all the parent refs
            // otherwise it will cause false-positive recursive detection
            this.exitParents(merged);
            return merged;
          }),
        };
      }
    }

    return schema;
  }
}

1	import { resolve as urlResolve } from 'url';	13✔
2
3	import { OpenAPIRef, OpenAPISchema, OpenAPISpec, Referenced } from '../types';
4
5	import { appendToMdHeading, IS_BROWSER } from '../utils/';	13✔
6	import { JsonPointer } from '../utils/JsonPointer';	13✔
7	import {	13✔
8	isNamedDefinition,
9	SECURITY_DEFINITIONS_COMPONENT_NAME,
10	SECURITY_DEFINITIONS_JSX_NAME,
11	} from '../utils/openapi';
12	import { buildComponentComment, MarkdownRenderer } from './MarkdownRenderer';	13✔
13	import { RedocNormalizedOptions } from './RedocNormalizedOptions';	13✔
14
15	export type MergedOpenAPISchema = OpenAPISchema & { parentRefs?: string[] };
16
17	/**
18	* Helper class to keep track of visited references to avoid
19	* endless recursion because of circular refs
20	*/
21	class RefCounter {	13✔
22	_counter = {};	89✔
23
24	reset(): void {	13✔
25	this._counter = {};	×
26	}
27
28	visit(ref: string): void {	13✔
29	this._counter[ref] = this._counter[ref] ? this._counter[ref] + 1 : 1;	823✔
30	}
31
32	exit(ref: string): void {	13✔
33	this._counter[ref] = this._counter[ref] && this._counter[ref] - 1;	823✔
34	}
35
36	visited(ref: string): boolean {	13✔
37	return !!this._counter[ref];	823✔
38	}
39	}	13✔
40
41	/**
42	* Loads and keeps spec. Provides raw spec operations
43	*/
44	export class OpenAPIParser {	13✔
45	specUrl?: string;
46	spec: OpenAPISpec;
47	mergeRefs: Set<string>;
48
49	private _refCounter: RefCounter = new RefCounter();	21✔
50
51	constructor(	21✔
52	spec: OpenAPISpec,
53	specUrl?: string,
54	private options: RedocNormalizedOptions = new RedocNormalizedOptions({}),	24✔
55	) {
56	this.validate(spec);	21✔
57	this.preprocess(spec);	21✔
58
59	this.spec = spec;	21✔
60
61	this.mergeRefs = new Set();	21✔
62
63	const href = IS_BROWSER ? window.location.href : '';	21!
64	if (typeof specUrl === 'string') {	21✔
65	this.specUrl = urlResolve(href, specUrl);	1✔
66	}
67	}
68
69	validate(spec: any) {	13✔
70	if (spec.openapi === undefined) {	21!
71	throw new Error('Document must be valid OpenAPI 3.0.0 definition');	×
72	}
73	}
74
75	preprocess(spec: OpenAPISpec) {	13✔
76	if (	21✔
77	!this.options.noAutoAuth &&	63✔
78	spec.info &&
79	spec.components &&
80	spec.components.securitySchemes
81	) {
82	// Automatically inject Authentication section with SecurityDefinitions component
83	const description = spec.info.description \|\| '';	2!
84	if (	2!
85	!MarkdownRenderer.containsComponent(description, SECURITY_DEFINITIONS_COMPONENT_NAME) &&	4✔
86	!MarkdownRenderer.containsComponent(description, SECURITY_DEFINITIONS_JSX_NAME)
87	) {
88	const comment = buildComponentComment(SECURITY_DEFINITIONS_COMPONENT_NAME);	×
89	spec.info.description = appendToMdHeading(description, 'Authentication', comment);	×
90	}
91	}
92	}
93
94	/**
95	* get spec part by JsonPointer ($ref)
96	*/
97	byRef = <T extends any = any>(ref: string): T \| undefined => {	21✔
98	let res;
99	if (!this.spec) {	924!
100	return;	×
101	}
102	if (ref.charAt(0) !== '#') {	924!
103	ref = '#' + ref;	×
104	}
105	ref = decodeURIComponent(ref);	924✔
106	try {	924✔
107	res = JsonPointer.get(this.spec, ref);	924✔
108	} catch (e) {
109	// do nothing
110	}
111	return res \|\| {};	924!
112	};
113
114	/**
115	* checks if the object is OpenAPI reference (contains $ref property)
116	*/
117	isRef(obj: any): obj is OpenAPIRef {	13✔
118	if (!obj) {	10,806!
119	return false;	×
120	}
121	return obj.$ref !== undefined && obj.$ref !== null;	10,806✔
122	}
123
124	/**
125	* resets visited endpoints. should be run after
126	*/
127	resetVisited() {	13✔
128	if (process.env.NODE_ENV !== 'production') {	68!
129	// check in dev mode
130	for (const k in this._refCounter._counter) {	68✔
131	if (this._refCounter._counter[k] > 0) {	162!
132	console.warn('Not exited reference: ' + k);	×
133	}
134	}
135	}
136	this._refCounter = new RefCounter();	68✔
137	}
138
139	exitRef<T>(ref: Referenced<T>) {	13✔
140	if (!this.isRef(ref)) {	4,767✔
141	return;	3,944✔
142	}
143	this._refCounter.exit(ref.$ref);	823✔
144	}
145
146	/**
147	* Resolve given reference object or return as is if it is not a reference
148	* @param obj object to dereference
149	* @param forceCircular whether to dereference even if it is circular ref
150	*/
151	deref<T extends object>(obj: OpenAPIRef \| T, forceCircular = false): T {	9,762✔
152	if (this.isRef(obj)) {	5,268✔
153	const resolved = this.byRef<T>(obj.$ref)!;	823✔
154	const visited = this._refCounter.visited(obj.$ref);	823✔
155	this._refCounter.visit(obj.$ref);	823✔
156	if (visited && !forceCircular) {	823✔
157	// circular reference detected
158	// tslint:disable-next-line
159	return Object.assign({}, resolved, { 'x-circular-ref': true });	96✔
160	}
161	// deref again in case one more $ref is here
162	if (this.isRef(resolved)) {	727!
163	const res = this.deref(resolved);	×
164	this.exitRef(resolved);	×
165	return res;	×
166	}
167	if (obj['x-description']) {	727!
168	return Object.assign({}, resolved, { description: obj['x-description'] });	×
169	}
170	return resolved;	727✔
171	}
172	return obj;	4,445✔
173	}
174
175	shalowDeref<T extends object>(obj: OpenAPIRef \| T): T {	13✔
176	if (this.isRef(obj)) {	44!
177	return this.byRef<T>(obj.$ref)!;	×
178	}
179	return obj;	44✔
180	}
181
182	/**
183	* Merge allOf constraints.
184	* @param schema schema with allOF
185	* @param $ref pointer of the schema
186	* @param forceCircular whether to dereference children even if it is a circular ref
187	*/
188	mergeAllOf(	2,985✔
189	schema: OpenAPISchema,
190	$ref?: string,
191	forceCircular: boolean = false,	3,026✔
192	used$Refs = new Set<string>(),	5,196✔
193	): MergedOpenAPISchema {
194	if ($ref) {	2,985✔
195	used$Refs.add($ref);	2,780✔
196	}
197
198	schema = this.hoistOneOfs(schema);	2,985✔
199
200	if (schema.allOf === undefined) {	2,985✔
201	return schema;	2,324✔
202	}
203
204	let receiver: MergedOpenAPISchema = {	661✔
205	...schema,
206	allOf: undefined,
207	parentRefs: [],
208	title: schema.title \|\| (isNamedDefinition($ref) ? JsonPointer.baseName($ref) : undefined),	1,927✔
209	};
210
211	// avoid mutating inner objects
212	if (receiver.properties !== undefined && typeof receiver.properties === 'object') {	661✔
213	receiver.properties = { ...receiver.properties };	30✔
214	}
215	if (receiver.items !== undefined && typeof receiver.items === 'object') {	661✔
216	receiver.items = { ...receiver.items };	1✔
217	}
218
219	const allOfSchemas = schema.allOf	661✔
220	.map(subSchema => {
221	if (subSchema && subSchema.$ref && used$Refs.has(subSchema.$ref)) {	774!
222	return undefined;	×
223	}
224
225	const resolved = this.deref(subSchema, forceCircular);	774✔
226	const subRef = subSchema.$ref \|\| undefined;	774✔
227	const subMerged = this.mergeAllOf(resolved, subRef, forceCircular, used$Refs);	774✔
228	receiver.parentRefs!.push(...(subMerged.parentRefs \|\| []));	774✔
229	return {	774✔
230	$ref: subRef,
231	schema: subMerged,
232	};
233	})
234	.filter(child => child !== undefined) as Array<{	774✔
235	$ref: string \| undefined;
236	schema: MergedOpenAPISchema;
237	}>;
238
239	for (const { $ref: subSchemaRef, schema: subSchema } of allOfSchemas) {	1,322✔
240	if (	774!
241	receiver.type !== subSchema.type &&	1,465✔
242	receiver.type !== undefined &&
243	subSchema.type !== undefined
244	) {
245	console.warn(	×
246	`Incompatible types in allOf at "${$ref}": "${receiver.type}" and "${subSchema.type}"`,
247	);
248	}
249
250	if (subSchema.type !== undefined) {	774✔
251	receiver.type = subSchema.type;	722✔
252	}
253
254	if (subSchema.properties !== undefined) {	774✔
255	receiver.properties = receiver.properties \|\| {};	410✔
256	for (const prop in subSchema.properties) {	410✔
257	if (!receiver.properties[prop]) {	1,974!
258	receiver.properties[prop] = subSchema.properties[prop];	1,974✔
259	} else {
260	// merge inner properties
261	receiver.properties[prop] = this.mergeAllOf(	×
262	{ allOf: [receiver.properties[prop], subSchema.properties[prop]] },
263	$ref + '/properties/' + prop,
264	);
265	}
266	}
267	}
268
269	if (subSchema.items !== undefined) {	774!
270	receiver.items = receiver.items \|\| {};	×
271	// merge inner properties
272	receiver.items = this.mergeAllOf(	×
273	{ allOf: [receiver.items, subSchema.items] },
274	$ref + '/items',
275	);
276	}
277
278	if (subSchema.required !== undefined) {	774✔
279	receiver.required = (receiver.required \|\| []).concat(subSchema.required);	298✔
280	}
281
282	// merge rest of constraints
283	// TODO: do more intelligent merge
284	receiver = { ...subSchema, ...receiver };	774✔
285
286	if (subSchemaRef) {	774✔
287	receiver.parentRefs!.push(subSchemaRef);	624✔
288	if (receiver.title === undefined && isNamedDefinition(subSchemaRef)) {	624✔
289	// this is not so correct behaviour. commented out for now
290	// ref: https://github.com/Redocly/redoc/issues/601
291	// receiver.title = JsonPointer.baseName(subSchemaRef);
292	}
293	}
294	}
295
296	return receiver;	661✔
297	}
298
299	/**
300	* Find all derived definitions among #/components/schemas from any of $refs
301	* returns map of definition pointer to definition name
302	* @param $refs array of references to find derived from
303	*/
304	findDerived($refs: string[]): Record<string, string[] \| string> {	13✔
305	const res: Record<string, string[]> = {};	35✔
306	const schemas = (this.spec.components && this.spec.components.schemas) \|\| {};	35!
307	for (const defName in schemas) {	35✔
308	const def = this.deref(schemas[defName]);	329✔
309	if (	329✔
310	def.allOf !== undefined &&	430✔
311	def.allOf.find(obj => obj.$ref !== undefined && $refs.indexOf(obj.$ref) > -1)	138✔
312	) {
313	res['#/components/schemas/' + defName] = [def['x-discriminator-value'] \|\| defName];	65✔
314	}
315	}
316	return res;	35✔
317	}
318
319	exitParents(shema: MergedOpenAPISchema) {	13✔
320	for (const parent$ref of shema.parentRefs \|\| []) {	2,210✔
321	this.exitRef({ $ref: parent$ref });	624✔
322	}
323	}
324
325	private hoistOneOfs(schema: OpenAPISchema) {	2,985✔
326	if (schema.allOf === undefined) {	2,985✔
327	return schema;	2,321✔
328	}
329
330	const allOf = schema.allOf;	664✔
331	for (let i = 0; i < allOf.length; i++) {	781✔
332	const sub = allOf[i];	781✔
333	if (Array.isArray(sub.oneOf)) {	781✔
334	const beforeAllOf = allOf.slice(0, i);	3✔
335	const afterAllOf = allOf.slice(i + 1);	3✔
336	return {	3✔
337	oneOf: sub.oneOf.map(part => {
338	const merged = this.mergeAllOf({	6✔
339	allOf: [...beforeAllOf, part, ...afterAllOf],
340	});
341
342	// each oneOf should be independent so exiting all the parent refs
343	// otherwise it will cause false-positive recursive detection
344	this.exitParents(merged);	6✔
345	return merged;	6✔
346	}),
347	};
348	}
349	}
350
351	return schema;	661✔
352	}
353	}	13✔

Redocly / redoc / 1798

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous