@redocly/openapi-core 1.0.0-beta.98 → 1.0.0-beta.99

package/src/rules/oas3/__tests__/response-contains-property.test.ts

@@ -0,0 +1,403 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 response-contains-property', () => {
+  it('should report a response object not containing the property', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+		`);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { 201: ['id'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1store~1subscribe/post/responses/201/content/application~1json/schema/properties",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "Response object must contain a top-level \\"id\\" property.",
+          "ruleId": "response-contains-property",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report response objects not containing props for a subset of status codes', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+              400:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        status:
+                          type: integer
+                description: error
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { '2xx': ['id'], '400': ['error'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1store~1subscribe/post/responses/201/content/application~1json/schema/properties",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+              400:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        status:
+                          type: integer
+                description: error",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "Response object must contain a top-level \\"id\\" property.",
+          "ruleId": "response-contains-property",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1store~1subscribe/post/responses/400/content/application~1json/schema/properties",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+              400:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        status:
+                          type: integer
+                description: error",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "Response object must contain a top-level \\"error\\" property.",
+          "ruleId": "response-contains-property",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report response objects containing specified properties', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+                        id: some-id
+              400:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        status:
+                          type: integer
+                        error:
+                          type: string
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { '2xx': ['id'], '400': ['error'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report a response object when schema type is not object', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  text/plain:
+                    schema:
+                      type: string
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { 201: ['id'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report response objects when there is no `names` field specified', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '201':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456
+              400:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        status:
+                          type: integer
+                description: error
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report response objects for 204 status code', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              '204':
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        subscriptionId:
+                          type: string
+                          example: AAA-123-BBB-456                  
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { '2xx': ['id'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should report response objects when there are no properties', async () => {
+    const document = parseYamlToDocument(outdent`
+      openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              200:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                                      
+      `);
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'response-contains-property': {
+          severity: 'error',
+          names: { '2xx': ['id'] },
+        },
+      }),
+    });
+    expect(results).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1store~1subscribe/post/responses/200/content/application~1json/schema/properties",
+              "reportOnKey": true,
+              "source": Source {
+                "absoluteRef": "",
+                "body": "openapi: 3.0.3
+      info:
+        version: 3.0.0
+      paths:
+        /store/subscribe:
+          post:
+            responses:
+              200:
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                                      ",
+                "mimeType": undefined,
+              },
+            },
+          ],
+          "message": "Response object must contain a top-level \\"id\\" property.",
+          "ruleId": "response-contains-property",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});

package/src/rules/oas3/index.ts

@@ -45,6 +45,9 @@ import { PathSegmentPlural } from '../common/path-segment-plural';
 import { PathExcludesPatterns } from '../common/path-excludes-patterns';
 import { NoInvalidSchemaExamples } from '../common/no-invalid-schema-examples';
 import { NoInvalidParameterExamples } from '../common/no-invalid-parameter-examples';
+import { ResponseContainsHeader } from '../common/response-contains-header';
+import { ResponseContainsProperty } from './response-contains-property';
+import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example';
 
 export const rules = {
   spec: OasSpec,
@@ -94,6 +97,9 @@ export const rules = {
   'path-segment-plural': PathSegmentPlural,
   'no-invalid-schema-examples': NoInvalidSchemaExamples,
   'no-invalid-parameter-examples': NoInvalidParameterExamples,
+  'response-contains-header': ResponseContainsHeader,
+  'response-contains-property': ResponseContainsProperty,
+  'scalar-property-missing-example': ScalarPropertyMissingExample,
 } as Oas3RuleSet;
 
 export const preprocessors = {};

package/src/rules/oas3/response-contains-property.ts

@@ -0,0 +1,38 @@
+import { Oas3Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { getMatchingStatusCodeRange } from '../../utils';
+
+export const ResponseContainsProperty: Oas3Rule = (options) => {
+  const names: Record<string, string[]> = options.names || {};
+  let key: string | number;
+  return {
+    Operation: {
+      Response: {
+        skip: (_response, key) => {
+          return `${key}` === '204';
+        },
+        enter: (_response, ctx: UserContext) => {
+          key = ctx.key;
+        },
+        MediaType: {
+          Schema(schema, { report, location }) {
+            if (schema.type !== 'object') return;
+            const expectedProperties =
+              names[key] ||
+              names[getMatchingStatusCodeRange(key)] ||
+              names[getMatchingStatusCodeRange(key).toLowerCase()] ||
+              [];
+            for (const expectedProperty of expectedProperties) {
+              if (!schema.properties?.[expectedProperty]) {
+                report({
+                  message: `Response object must contain a top-level "${expectedProperty}" property.`,
+                  location: location.child('properties').key(),
+                });
+              }
+            }
+          },
+        },
+      },
+    },
+  };
+};

package/src/types/oas3.ts

@@ -275,14 +275,14 @@ const Schema: NodeType = {
     minimum: { type: 'number' },
     exclusiveMaximum: { type: 'boolean' },
     exclusiveMinimum: { type: 'boolean' },
-    maxLength: { type: 'number', minimum: 0 },
-    minLength: { type: 'number', minimum: 0 },
+    maxLength: { type: 'integer', minimum: 0 },
+    minLength: { type: 'integer', minimum: 0 },
     pattern: { type: 'string' },
-    maxItems: { type: 'number', minimum: 0 },
-    minItems: { type: 'number', minimum: 0 },
+    maxItems: { type: 'integer', minimum: 0 },
+    minItems: { type: 'integer', minimum: 0 },
     uniqueItems: { type: 'boolean' },
-    maxProperties: { type: 'number', minimum: 0 },
-    minProperties: { type: 'number', minimum: 0 },
+    maxProperties: { type: 'integer', minimum: 0 },
+    minProperties: { type: 'integer', minimum: 0 },
     required: { type: 'array', items: { type: 'string' } },
     enum: { type: 'array' },
     type: {
@@ -300,6 +300,15 @@ const Schema: NodeType = {
         return 'Schema';
       }
     },
+    additionalItems: (value: any) => {
+      if (typeof value === 'boolean') {
+        return { type: 'boolean' };
+      } else if (Array.isArray(value)) {
+        return listOf('Schema');
+      } else {
+        return 'Schema';
+      }
+    },
     additionalProperties: (value: any) => {
       if (typeof value === 'boolean') {
         return { type: 'boolean' };

package/src/types/oas3_1.ts

@@ -90,19 +90,19 @@ const Schema: NodeType = {
     discriminator: 'Discriminator',
     myArbitraryKeyword: { type: 'boolean' },
     title: { type: 'string' },
-    multipleOf: { type: 'number' },
+    multipleOf: { type: 'number', minimum: 0 },
     maximum: { type: 'number' },
     minimum: { type: 'number' },
     exclusiveMaximum: { type: 'number' },
     exclusiveMinimum: { type: 'number' },
-    maxLength: { type: 'number' },
-    minLength: { type: 'number' },
+    maxLength: { type: 'integer', minimum: 0 },
+    minLength: { type: 'integer', minimum: 0 },
     pattern: { type: 'string' },
-    maxItems: { type: 'number' },
-    minItems: { type: 'number' },
+    maxItems: { type: 'integer', minimum: 0 },
+    minItems: { type: 'integer', minimum: 0 },
     uniqueItems: { type: 'boolean' },
-    maxProperties: { type: 'number' },
-    minProperties: { type: 'number' },
+    maxProperties: { type: 'integer', minimum: 0 },
+    minProperties: { type: 'integer', minimum: 0 },
     required: { type: 'array', items: { type: 'string' } },
     enum: { type: 'array' },
     type: (value: any) => {
@@ -127,6 +127,8 @@ const Schema: NodeType = {
     dependentSchemas: listOf('Schema'),
     prefixItems: listOf('Schema'),
     contains: 'Schema',
+    minContains: { type: 'integer', minimum: 0 },
+    maxContains: { type: 'integer', minimum: 0 },
     patternProperties: { type: 'object' },
     propertyNames: 'Schema',
     unevaluatedItems: 'Schema',

package/src/types/redocly-yaml.ts

@@ -392,6 +392,7 @@ const LinksConfig: NodeType = {
     color: { type: 'string' },
     hover: { type: 'string' },
     textDecoration: { type: 'string' },
+    hoverTextDecoration: { type: 'string' },
     visited: { type: 'string' },
   },
 };
@@ -513,6 +514,9 @@ const ConfigReferenceDocs: NodeType = {
     disableSidebar: { type: 'boolean' },
     downloadDefinitionUrl: { type: 'string' },
     expandDefaultServerVariables: { type: 'boolean' },
+    enumSkipQuotes: { type: 'boolean' },
+    expandDefaultRequest: { type: 'boolean'},
+    expandDefaultResponse: { type: 'boolean'},
     expandResponses: { type: 'string' },
     expandSingleSchemaField: { type: 'boolean' },
     generateCodeSamples: 'GenerateCodeSamples',
@@ -527,6 +531,8 @@ const ConfigReferenceDocs: NodeType = {
     hideSchemaTitles: { type: 'boolean' },
     hideSingleRequestSampleTab: { type: 'boolean' },
     hideTryItPanel: { type: 'boolean' },
+    hideFab: { type: 'boolean' },
+    hideOneOfDescription: { type: 'boolean'},
     htmlTemplate: { type: 'string' },
     jsonSampleExpandLevel: { type: 'string' },
     labels: 'ConfigLabels',
@@ -547,6 +553,8 @@ const ConfigReferenceDocs: NodeType = {
     samplesTabsMaxCount: { type: 'number' },
     schemaExpansionLevel: { type: 'string' },
     schemaDefinitionsTagName: { type: 'string' },
+    minCharacterLengthToInitSearch: { type: 'number' },
+    maxResponseHeadersToShowInTryIt: {type: 'number'},
     scrollYOffset: { type: 'string' },
     searchAutoExpand: { type: 'boolean' },
     searchFieldLevelBoost: { type: 'number' },
@@ -558,6 +566,8 @@ const ConfigReferenceDocs: NodeType = {
     showExtensions: { type: 'boolean' },
     showNextButton: { type: 'boolean' },
     showRightPanelToggle: { type: 'boolean' },
+    showWebhookVerb: { type: 'boolean' },
+    showObjectSchemaExamples: { type: 'boolean' },
     sidebarLinks: 'ConfigSidebarLinks',
     sideNavStyle: { type: 'string' },
     simpleOneOfTypeLabel: { type: 'boolean' },

package/src/typings/openapi.ts

@@ -153,7 +153,8 @@ export interface Oas3Schema {
   'x-tags'?: string[];
 }
 
-export interface Oas3_1Schema extends Oas3Schema {
+export type Oas3_1Schema = Oas3Schema & {
+  type?: string | string[];
   examples?: any[];
 }
 

package/src/utils.ts

@@ -188,3 +188,6 @@ export function assignExisting<T>(target: Record<string, T>, obj: Record<string,
     }
   }
 }
+
+export const getMatchingStatusCodeRange = (code: number | string): string =>
+  `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);