@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

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

@@ -0,0 +1,694 @@
+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

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