@redocly/openapi-docs 3.24.1 → 3.25.0-next.1

package/lib/models/__tests__/Schema.circular.test.js

@@ -1,694 +0,0 @@
-import outdent from 'outdent';
-import { parseYaml } from '@redocly/openapi-core';
-import { getSchema } from '../schema.js';
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-import { circularDetailsPrinter, printSchema } from './helpers.js';
-const options = normalizeOptions({});
-const deps = { operation: { pointer: 'testSchemaCircular' } };
-describe('Models', () => {
-    describe('Schema Circular tracking', () => {
-        let parser;
-        expect.addSnapshotSerializer({
-            test: (val) => typeof val === 'string',
-            print: (v) => v,
-        });
-        test('should detect circular for array nested in allOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Schema:
-            type: object
-            properties:
-              a: { $ref: '#/components/schemas/Schema' }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Schema,
-                pointer: '#/components/schemas/Schema',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`a: <object> !circular`);
-        });
-        test('should not detect circular refs when ref used multiple times across allOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Foo:
-            type: object
-            properties:
-              foo: { type: string }
-          Schema:
-            allOf:
-              - $ref: '#/components/schemas/Foo'
-              - type: object
-                properties:
-                  foobar: { $ref: '#/components/schemas/Foo' }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Schema,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        foo: <string>
-        foobar:
-          foo: <string>
-      `);
-        });
-        test('should detect circular for array with self-reference', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Array:
-            type: "array"
-            items: { "$ref": "#/components/schemas/Array" }
-          Schema:
-            allOf: [{ "$ref": "#/components/schemas/Array" }]
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Schema,
-                pointer: '#/components/schemas/Schema',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`[<array> !circular]`);
-        });
-        test('should detect circular for object nested in allOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Object:
-            allOf:
-              - $ref: '#/components/schemas/Object'
-              - type: "object"
-                properties: { "a": { "$ref": "#/components/schemas/Object" } }
-          Schema:
-            allOf: [{ "$ref": "#/components/schemas/Object" }]
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Schema,
-                pointer: '#/components/schemas/Schema',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`a: <any> !circular`);
-        });
-        test('should not detect circular for base DTO case', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          BaseDTO:
-            type: object
-            properties:
-              id: {type: string}
-          BaseB:
-            type: object
-            allOf:
-              - $ref: '#/components/schemas/BaseDTO'
-              - type: object
-                properties:
-                  fieldB: { type: string }
-          BaseA:
-            type: object
-            allOf:
-              - $ref: '#/components/schemas/BaseDTO'
-              - type: object
-                properties:
-                  b: { $ref: '#/components/schemas/BaseB' }
-                  fieldA: { type: string }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.BaseA,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        id: <string>
-        b:
-          id: <string>
-          fieldB: <string>
-        fieldA: <string>
-      `);
-        });
-        test('should detect circular ref for self referencing discriminator', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          SelfComponentDto:
-            type: object
-            properties:
-              self:
-                type: object
-                discriminator:
-                  propertyName: schemaId
-                  mapping:
-                    title: '#/components/schemas/SelfComponentDto'
-                oneOf:
-                  - $ref: '#/components/schemas/SelfComponentDto'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.SelfComponentDto,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        self: oneOf
-            title ->
-              self: oneOf
-                  title -> <object> !circular
-      `);
-        });
-        test('should detect circular with nested oneOf hoisting', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Node:
-            type: 'object'
-            allOf:
-              - oneOf:
-                - type: object
-                  properties:
-                    parent:
-                      $ref: '#/components/schemas/Node'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Node,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        oneOf
-          object ->
-            parent: oneOf
-                object ->
-                  parent: <object> !circular
-      `);
-        });
-        test('should detect simple props recursion', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          PropRecursion:
-            properties:
-              children:
-                type: object
-                properties:
-                  a:
-                    $ref: '#/components/schemas/PropRecursion'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.PropRecursion,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        children:
-          a:
-            children:
-              a: <object> !circular
-      `);
-        });
-        test('should detect recursion for props with type array', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          PropsRecursion:
-            properties:
-              children:
-                type: array
-                items:
-                  $ref: '#/components/schemas/PropsRecursion'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.PropsRecursion,
-                pointer: '',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        children: [
-          children: [<object> !circular]
-        ]
-      `);
-        });
-        test('should detect and ignore allOf recursion', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Parent:
-            $ref: '#/components/schemas/Child'
-          Child:
-            allOf:
-              - $ref: '#/components/schemas/Parent'
-              - type: object
-                properties:
-                  a:
-                    type: string
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Child,
-                pointer: '#/components/schemas/Child',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`a: <string>`);
-        });
-        test('should detect and ignore allOf recursion in nested prop', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          ExternalReference:
-            type: object
-            allOf:
-              - $ref: '#/components/schemas/CompanyReference'
-              - type: object
-                properties:
-                  externalId: { type: string }
-          CompanyReference:
-            type: object
-            required: [ guid, externalId ]
-            properties:
-              guid: { type: string }
-              nestedRecursive: { $ref: '#/components/schemas/ExternalReference' }
-          Entity:
-            type: object
-            allOf:
-              - $ref: '#/components/schemas/ExternalReference'
-              - type: object
-                properties:
-                  directRecursive: { $ref: '#/components/schemas/ExternalReference' }
-                  selfRecursive: { $ref: '#/components/schemas/Entity' }
-                  anotherField: { $ref: '#/components/schemas/AnotherEntity' }
-          AnotherEntity:
-            type: object
-            allOf:
-              - $ref: '#/components/schemas/CompanyReference'
-              - type: object
-                properties:
-                  someField: { type: number }
-                  anotherSelfRecursive: { $ref: '#/components/schemas/AnotherEntity' }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Entity,
-                pointer: '#/components/schemas/Entity',
-                options,
-                deps,
-            });
-            // TODO: this has a little issue with too early detection in anotherField -> nestedRecursive
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        guid*: <string>
-        nestedRecursive: <object> !circular
-        externalId*: <string>
-        directRecursive:
-          guid*: <string>
-          nestedRecursive: <object> !circular
-          externalId*: <string>
-        selfRecursive: <object> !circular
-        anotherField:
-          guid*: <string>
-          nestedRecursive: <object> !circular
-          someField: <number>
-          anotherSelfRecursive: <object> !circular
-      `);
-        });
-        test('should detect and ignore allOf with discriminator recursion', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Pet:
-            type: object
-            required: [ petType ]
-            discriminator:
-              propertyName: petType
-              mapping:
-                cat: '#/components/schemas/Cat'
-                dog: '#/components/schemas/Dog'
-            properties:
-              category: { $ref: '#/components/schemas/Category' }
-              status: { type: string }
-              friend:
-                allOf: [{ $ref: '#/components/schemas/Pet' }]
-              petType: { type: string }
-          Cat:
-            description: A representation of a cat
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  huntingSkill: { type: string }
-          Dog:
-            description: A representation of a dog
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  packSize: { type: integer }
-          Category:
-            type: object
-            properties:
-              name: { type: string }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Pet,
-                pointer: '#/components/schemas/Pet',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        oneOf
-          cat ->
-            category:
-              name: <string>
-            status: <string>
-            friend: <object> !circular
-            petType*: <string>
-            huntingSkill: <string>
-          dog ->
-            category:
-              name: <string>
-            status: <string>
-            friend: <object> !circular
-            petType*: <string>
-            packSize: <integer>
-      `);
-        });
-        test('should detect and recursion on the right level with array of discriminators', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Pet:
-            type: object
-            required: [ petType ]
-            discriminator:
-              propertyName: petType
-              mapping:
-                cat: '#/components/schemas/Cat'
-                dog: '#/components/schemas/Dog'
-            properties:
-              category: { $ref: '#/components/schemas/Category' }
-              status: { type: string }
-              friend:
-                allOf: [{ $ref: '#/components/schemas/Pet' }]
-              petType: { type: string }
-          Cat:
-            description: A representation of a cat
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  huntingSkill: { type: string }
-          Dog:
-            description: A representation of a dog
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  packSize: { type: integer }
-          Category:
-            type: object
-            properties:
-              name: { type: string }
-          Response:
-            type: array
-            items:
-              $ref: '#/components/schemas/Pet'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Response,
-                pointer: '#/components/schemas/Response',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        [
-        oneOf
-          cat ->
-            category:
-              name: <string>
-            status: <string>
-            friend: <object> !circular
-            petType*: <string>
-            huntingSkill: <string>
-          dog ->
-            category:
-              name: <string>
-            status: <string>
-            friend: <object> !circular
-            petType*: <string>
-            packSize: <integer>
-        ]
-      `);
-        });
-        test('should detect and recursion with discriminator and oneOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          User:
-            type: object
-            properties:
-              pet:
-                oneOf:
-                  - $ref: '#/components/schemas/Pet'
-          Pet:
-            type: object
-            required: [ petType ]
-            discriminator:
-              propertyName: petType
-              mapping:
-                cat: '#/components/schemas/Cat'
-                dog: '#/components/schemas/Dog'
-            properties:
-              category: { $ref: '#/components/schemas/Category' }
-              status: { type: string }
-              friend:
-                allOf: [{ $ref: '#/components/schemas/Pet' }]
-              petType: { type: string }
-          Cat:
-            description: A representation of a cat
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  huntingSkill: { type: string }
-          Dog:
-            description: A representation of a dog
-            allOf:
-              - $ref: '#/components/schemas/Pet'
-              - type: object
-                properties:
-                  packSize: { type: integer }
-          Category:
-            type: object
-            properties:
-              name: { type: string }
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.User,
-                pointer: '#/components/schemas/User',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-      pet: oneOf
-          Pet -> oneOf
-              cat ->
-                category:
-                  name: <string>
-                status: <string>
-                friend: <object> !circular
-                petType*: <string>
-                huntingSkill: <string>
-              dog ->
-                category:
-                  name: <string>
-                status: <string>
-                friend: <object> !circular
-                petType*: <string>
-                packSize: <integer>
-      `);
-        });
-        test('should detect and recursion with nested oneOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Tag:
-            type: object
-            properties:
-              name:
-                description: Tag name
-                type: string
-                minLength: 1
-              items:
-                oneOf:
-                  - $ref: "#/components/schemas/Tag"
-          User:
-            type: object
-            properties:
-              pet:
-                oneOf:
-                  - $ref: '#/components/schemas/Tag'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.User,
-                pointer: '#/components/schemas/User',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-      pet: oneOf
-          Tag ->
-            name: <string> (Tag name)
-            items: oneOf
-                Tag -> <object> !circular
-      `);
-        });
-        test('should not use discriminator for direct schemas refs in oneOf/anyOf', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.0.0
-      components:
-        schemas:
-          Parent:
-            type: object
-            discriminator:
-              propertyName: type
-              mapping:
-                foo: '#/components/schemas/Foo'
-                bar: '#/components/schemas/Bar'
-                baz: '#/components/schemas/Baz'
-            properties:
-              type:
-                type: string
-          Foo:
-            allOf:
-              - $ref: '#/components/schemas/Parent'
-              - type: object
-          Bar:
-            allOf:
-            - $ref: '#/components/schemas/Parent'
-            - type: object
-          Baz:
-            allOf:
-            - $ref: '#/components/schemas/Parent'
-            - type: object
-              properties:
-                nested:
-                  anyOf:
-                    - $ref: '#/components/schemas/Foo'
-                    - $ref: '#/components/schemas/Bar'
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.Parent,
-                pointer: '#/components/schemas/Parent',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        oneOf
-          foo ->
-            type: <string>
-          bar ->
-            type: <string>
-          baz ->
-            type: <string>
-            nested: oneOf
-                Foo ->
-                  type: <string>
-                Bar ->
-                  type: <string>
-        `);
-        });
-        test('should use titles in oneOf schemas and should not be recursive', () => {
-            const spec = parseYaml(outdent `
-      openapi: 3.1.0
-      components:
-        schemas:
-          OneOfTitle:
-            oneOf:
-                - $ref: "#/components/schemas/Foo"
-                - $ref: "#/components/schemas/Bar"
-          Foo:
-            title: Foo Title
-            type: object
-            description: test Foo description
-            properties:
-              type:
-                type: string
-          Bar:
-            title: Bar Title
-            type: object
-            description: test Bar description
-            properties:
-              type:
-                type: string
-      `);
-            parser = new OpenAPIParser(spec, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: spec.components.schemas.OneOfTitle,
-                pointer: '#/components/schemas/OneOfTitle',
-                options,
-                deps,
-            });
-            expect(printSchema(schema, circularDetailsPrinter)).toMatchInlineSnapshot(`
-        oneOf
-          Foo Title ->
-            type: <string>
-          Bar Title ->
-            type: <string>
-      `);
-        });
-    });
-});
-//# sourceMappingURL=Schema.circular.test.js.map

package/lib/models/__tests__/Schema.test.d.ts

@@ -1 +0,0 @@
-export {};