@redocly/openapi-core 1.28.5 → 1.29.0

package/src/rules/common/__tests__/no-schema-type-mismatch.test.ts

@@ -0,0 +1,126 @@
+import { outdent } from 'outdent';
+import { makeConfig, parseYamlToDocument, replaceSourceWithRef } from '../../../../__tests__/utils';
+import { lintDocument } from '../../../lint';
+import { BaseResolver } from '../../../resolve';
+
+describe('no-schema-type-mismatch rule', () => {
+  it('should report a warning for object type with items field', async () => {
+    const yaml = outdent`
+      openapi: 3.0.0
+      info:
+        title: Test API
+        version: 1.0.0
+      paths:
+        /test:
+          get:
+            responses:
+              '200':
+                description: OK
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      items:
+                        type: string
+    `;
+
+    const document = parseYamlToDocument(yaml, 'test.yaml');
+    const results = await lintDocument({
+      document,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig({ rules: { 'no-schema-type-mismatch': 'warn' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toEqual([
+      {
+        location: [
+          {
+            pointer: '#/paths/~1test/get/responses/200/content/application~1json/schema/items',
+            reportOnKey: false,
+            source: 'test.yaml',
+          },
+        ],
+        message: "Schema type mismatch: 'object' type should not contain 'items' field.",
+        ruleId: 'no-schema-type-mismatch',
+        severity: 'warn',
+        suggest: [],
+      },
+    ]);
+  });
+
+  it('should report a warning for array type with properties field', async () => {
+    const yaml = outdent`
+      openapi: 3.0.0
+      info:
+        title: Test API
+        version: 1.0.0
+      paths:
+        /test:
+          get:
+            responses:
+              '200':
+                description: OK
+                content:
+                  application/json:
+                    schema:
+                      type: array
+                      properties:
+                        name:
+                          type: string
+    `;
+
+    const document = parseYamlToDocument(yaml, 'test.yaml');
+    const results = await lintDocument({
+      document,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig({ rules: { 'no-schema-type-mismatch': 'warn' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toEqual([
+      {
+        location: [
+          {
+            pointer: '#/paths/~1test/get/responses/200/content/application~1json/schema/properties',
+            reportOnKey: false,
+            source: 'test.yaml',
+          },
+        ],
+        message: "Schema type mismatch: 'array' type should not contain 'properties' field.",
+        ruleId: 'no-schema-type-mismatch',
+        severity: 'warn',
+        suggest: [],
+      },
+    ]);
+  });
+
+  it('should not report a warning for valid schemas', async () => {
+    const yaml = outdent`
+      openapi: 3.0.0
+      info:
+        title: Test API
+        version: 1.0.0
+      paths:
+        /test:
+          get:
+            responses:
+              '200':
+                description: OK
+                content:
+                  application/json:
+                    schema:
+                      type: object
+                      properties:
+                        name:
+                          type: string
+    `;
+
+    const document = parseYamlToDocument(yaml, 'test.yaml');
+    const results = await lintDocument({
+      document,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig({ rules: { 'no-schema-type-mismatch': 'warn' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toEqual([]);
+  });
+});

package/src/rules/common/no-schema-type-mismatch.ts

@@ -0,0 +1,24 @@
+import type { Oas3Schema } from '../../typings/openapi';
+import type { Oas2Schema } from '../../typings/swagger';
+import type { Oas2Rule, Oas3Rule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const NoSchemaTypeMismatch: Oas3Rule | Oas2Rule = () => {
+  return {
+    Schema(schema: Oas2Schema | Oas3Schema, { report, location }: UserContext) {
+      if (schema.type === 'object' && schema.items) {
+        report({
+          message: "Schema type mismatch: 'object' type should not contain 'items' field.",
+          location: location.child('items'),
+        });
+      }
+
+      if (schema.type === 'array' && schema.properties) {
+        report({
+          message: "Schema type mismatch: 'array' type should not contain 'properties' field.",
+          location: location.child('properties'),
+        });
+      }
+    },
+  };
+};

package/src/rules/oas2/index.ts

@@ -42,6 +42,7 @@ import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-
 import { RequiredStringPropertyMissingMinLength } from '../common/required-string-property-missing-min-length';
 import { SpecStrictRefs } from '../common/spec-strict-refs';
 import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined';
+import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch';
 
 import type { Oas2Rule } from '../../visitors';
 import type { Oas2RuleSet } from '../../oas-types';
@@ -95,6 +96,7 @@ export const rules: Oas2RuleSet<'built-in'> = {
   'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength as Oas2Rule,
   'spec-strict-refs': SpecStrictRefs as Oas2Rule,
   'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined as Oas2Rule,
+  'no-schema-type-mismatch': NoSchemaTypeMismatch as Oas2Rule,
 };
 
 export const preprocessors = {};

package/src/rules/oas3/__tests__/no-invalid-media-type-examples.test.ts

@@ -677,4 +677,54 @@ describe('no-invalid-media-type-examples', () => {
       ]
     `);
   });
+
+  it('should first report on unresolved ref rather than fail on validation', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.0
+        paths:
+          /groups:
+            get:
+              responses:
+                '200':
+                  content:
+                    application/json:
+                      schema:
+                        type: string
+                      examples:
+                        example1:
+                          $ref: '#/components/examples/NotExisting'
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {
+          'no-invalid-media-type-examples': 'warn',
+          'no-unresolved-refs': 'error',
+        },
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/paths/~1groups/get/responses/200/content/application~1json/examples/example1",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref",
+          "ruleId": "no-unresolved-refs",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
 });

package/src/rules/oas3/index.ts

@@ -54,6 +54,7 @@ import { SpecStrictRefs } from '../common/spec-strict-refs';
 import { ComponentNameUnique } from './component-name-unique';
 import { ArrayParameterSerialization } from './array-parameter-serialization';
 import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined';
+import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch';
 
 import type { Oas3RuleSet } from '../../oas-types';
 import type { Oas3Rule } from '../../visitors';
@@ -119,6 +120,7 @@ export const rules: Oas3RuleSet<'built-in'> = {
   'component-name-unique': ComponentNameUnique as Oas3Rule,
   'array-parameter-serialization': ArrayParameterSerialization,
   'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined as Oas3Rule,
+  'no-schema-type-mismatch': NoSchemaTypeMismatch as Oas3Rule,
 };
 
 export const preprocessors = {};

package/src/rules/oas3/no-invalid-media-type-examples.ts

@@ -37,7 +37,7 @@ export const ValidContentExamples: Oas3Rule = (opts) => {
             location = isMultiple ? resolved.location.child('value') : resolved.location;
             example = resolved.node;
           }
-          if (isMultiple && typeof example.value === 'undefined') {
+          if (isMultiple && typeof example?.value === 'undefined') {
             return;
           }
           validateExample(

package/src/types/overlay.ts

@@ -0,0 +1,40 @@
+import { type NodeType, listOf } from '.';
+
+const Root: NodeType = {
+  properties: {
+    overlay: { type: 'string' },
+    info: 'Info',
+    extends: { type: 'string' },
+    actions: 'Actions',
+  },
+  required: ['overlay', 'info', 'actions'],
+  extensionsPrefix: 'x-',
+};
+
+const Info: NodeType = {
+  properties: {
+    title: { type: 'string' },
+    version: { type: 'string' },
+  },
+  required: ['title', 'version'],
+  extensionsPrefix: 'x-',
+};
+
+const Actions: NodeType = listOf('Action');
+const Action: NodeType = {
+  properties: {
+    target: { type: 'string' },
+    description: { type: 'string' },
+    update: {}, // any
+    remove: { type: 'boolean' },
+  },
+  required: ['target'],
+  extensionsPrefix: 'x-',
+};
+
+export const Overlay1Types: Record<string, NodeType> = {
+  Root,
+  Info,
+  Actions,
+  Action,
+};

package/src/types/redocly-yaml.ts

@@ -1,8 +1,8 @@
 import { rootRedoclyConfigSchema } from '@redocly/config';
 import { listOf } from '.';
-import { omitObjectProps, pickObjectProps, isCustomRuleId } from '../utils';
-import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 import { SpecVersion, getTypes } from '../oas-types';
+import { isCustomRuleId, omitObjectProps, pickObjectProps } from '../utils';
+import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 
 import type { JSONSchema } from 'json-schema-to-ts';
 import type { NodeType } from '.';
@@ -48,6 +48,7 @@ const builtInOAS2Rules = [
   'spec-strict-refs',
   'no-unresolved-refs',
   'no-required-schema-properties-undefined',
+  'no-schema-type-mismatch',
   'boolean-parameter-prefixes',
   'request-mime-type',
   'response-contains-property',
@@ -96,6 +97,7 @@ const builtInOAS3Rules = [
   'spec-strict-refs',
   'no-unresolved-refs',
   'no-required-schema-properties-undefined',
+  'no-schema-type-mismatch',
   'boolean-parameter-prefixes',
   'component-name-unique',
   'no-empty-servers',

package/src/typings/arazzo.ts

@@ -142,7 +142,7 @@ export interface Workflow {
 }
 
 export interface ArazzoDefinition {
-  arazzo: '1.0.0';
+  arazzo: '1.0.1';
   info: InfoObject;
   sourceDescriptions: SourceDescription[];
   workflows: Workflow[];
@@ -169,4 +169,4 @@ export interface ArazzoDefinition {
 
 export const VERSION_PATTERN = /^1\.0\.\d+(-.+)?$/;
 
-export const ARAZZO_VERSIONS_SUPPORTED_BY_SPOT = ['1.0.0', '1.0.1'];
+export const ARAZZO_VERSIONS_SUPPORTED_BY_SPOT = ['1.0.1'];

package/src/typings/overlay.ts

@@ -0,0 +1,19 @@
+export interface InfoObject {
+  title: string;
+  version: string;
+}
+
+export interface ActionObject {
+  target: string;
+  description?: string;
+  update?: unknown;
+  remove?: boolean;
+}
+export interface Overlay1Definition {
+  overlay: '1.0.0';
+  info: InfoObject;
+  extends?: string;
+  actions: ActionObject[];
+}
+
+export const VERSION_PATTERN = /^1\.0\.\d+(-.+)?$/;