@redocly/openapi-core 1.27.2 → 1.28.1

package/src/__tests__/lint.test.ts

@@ -1674,4 +1674,99 @@ describe('lint', () => {
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
   });
+
+  it('should throw an error for $schema not expected here - OAS 3.0.x', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.4
+        info:
+          title: test json schema validation keyword $schema - should use an OAS Schema, not JSON Schema
+          version: 1.0.0
+        paths:
+          '/thing':
+            get:
+              summary: a sample api
+              responses:
+                '200':
+                  description: OK
+                  content:
+                    'application/json':
+                      schema:
+                        $schema: http://json-schema.org/draft-04/schema#
+                        type: object
+                        properties: {}
+      `,
+      ''
+    );
+
+    const configFilePath = path.join(__dirname, '..', '..', '..', 'redocly.yaml');
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: { spec: 'error' },
+        decorators: undefined,
+        configPath: configFilePath,
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "from": undefined,
+          "location": [
+            {
+              "pointer": "#/paths/~1thing/get/responses/200/content/application~1json/schema/$schema",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`$schema\` is not expected here.",
+          "ruleId": "struct",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should allow for $schema to be defined - OAS 3.1.x', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.1
+        info:
+          title: test json schema validation keyword $schema - should allow a JSON Schema
+          version: 1.0.0
+        paths:
+          '/thing':
+            get:
+              summary: a sample api
+              responses:
+                '200':
+                  description: OK
+                  content:
+                    'application/json':
+                      schema:
+                        $schema: http://json-schema.org/draft-04/schema#
+                        type: object
+                        properties: {}
+      `,
+      ''
+    );
+
+    const configFilePath = path.join(__dirname, '..', '..', '..', 'redocly.yaml');
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: { spec: 'error' },
+        decorators: undefined,
+        configPath: configFilePath,
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
 });

package/src/decorators/oas3/remove-unused-components.ts

@@ -2,17 +2,26 @@ import { isEmptyObject } from '../../utils';
 
 import type { Location } from '../../ref-utils';
 import type { Oas3Decorator } from '../../visitors';
-import type { Oas3Components, Oas3Definition } from '../../typings/openapi';
+import type {
+  Oas3Definition,
+  Oas3_1Definition,
+  Oas3Components,
+  Oas3_1Components,
+} from '../../typings/openapi';
 
 export const RemoveUnusedComponents: Oas3Decorator = () => {
   const components = new Map<
     string,
-    { usedIn: Location[]; componentType?: keyof Oas3Components; name: string }
+    {
+      usedIn: Location[];
+      componentType?: keyof (Oas3Components | Oas3_1Components);
+      name: string;
+    }
   >();
 
   function registerComponent(
     location: Location,
-    componentType: keyof Oas3Components,
+    componentType: keyof (Oas3Components | Oas3_1Components),
     name: string
   ): void {
     components.set(location.absolutePointer, {
@@ -22,7 +31,10 @@ export const RemoveUnusedComponents: Oas3Decorator = () => {
     });
   }
 
-  function removeUnusedComponents(root: Oas3Definition, removedPaths: string[]): number {
+  function removeUnusedComponents(
+    root: Oas3Definition | Oas3_1Definition,
+    removedPaths: string[]
+  ): number {
     const removedLengthStart = removedPaths.length;
 
     for (const [path, { usedIn, name, componentType }] of components) {

package/src/index.ts

@@ -18,13 +18,13 @@ export type {
   Oas3Definition,
   Oas3_1Definition,
   Oas3Components,
+  Oas3_1Components,
   Oas3PathItem,
   Oas3Paths,
   Oas3ComponentName,
   Oas3Schema,
   Oas3_1Schema,
   Oas3Tag,
-  Oas3_1Webhooks,
   Referenced,
   OasRef,
 } from './typings/openapi';

package/src/redocly/__tests__/redocly-client.test.ts

@@ -1,12 +1,7 @@
 import { setRedoclyDomain } from '../domains';
 import { RedoclyClient } from '../index';
 
-jest.mock('node-fetch', () => ({
-  default: jest.fn(() => ({
-    ok: true,
-    json: jest.fn().mockResolvedValue({}),
-  })),
-}));
+const originalFetch = global.fetch;
 
 describe('RedoclyClient', () => {
   const REDOCLY_DOMAIN_US = 'redocly.com';
@@ -15,6 +10,19 @@ describe('RedoclyClient', () => {
   const testRedoclyDomain = 'redoclyDomain.com';
   const testToken = 'test-token';
 
+  beforeAll(() => {
+    global.fetch = jest.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+      } as any)
+    );
+  });
+
+  afterAll(() => {
+    global.fetch = originalFetch;
+  });
+
   afterEach(() => {
     delete process.env.REDOCLY_DOMAIN;
     setRedoclyDomain('');

package/src/redocly/registry-api.ts

@@ -1,8 +1,6 @@
-import fetch from 'node-fetch';
 import { getProxyAgent, isNotEmptyObject } from '../utils';
 import { getRedoclyDomain } from './domains';
 
-import type { RequestInit, HeadersInit } from 'node-fetch';
 import type {
   NotFoundProblemResponse,
   PrepareFileuploadOKResponse,
@@ -43,10 +41,13 @@ export class RegistryApi {
       throw new Error('Unauthorized');
     }
 
-    const response = await fetch(
-      `${this.getBaseUrl()}${path}`,
-      Object.assign({}, options, { headers, agent: getProxyAgent() })
-    );
+    const requestOptions = {
+      ...options,
+      headers,
+      agent: getProxyAgent(),
+    };
+
+    const response = await fetch(`${this.getBaseUrl()}${path}`, requestOptions);
 
     if (response.status === 401) {
       throw new Error('Unauthorized');

package/src/rules/common/operation-tag-defined.ts

@@ -1,13 +1,13 @@
 import type { Oas3Rule, Oas2Rule } from '../../visitors';
 import type { Oas2Definition, Oas2Operation } from '../../typings/swagger';
-import type { Oas3Definition, Oas3Operation } from '../../typings/openapi';
+import type { Oas3Definition, Oas3_1Definition, Oas3Operation } from '../../typings/openapi';
 import type { UserContext } from '../../walk';
 
 export const OperationTagDefined: Oas3Rule | Oas2Rule = () => {
   let definedTags: Set<string>;
 
   return {
-    Root(root: Oas2Definition | Oas3Definition) {
+    Root(root: Oas2Definition | Oas3Definition | Oas3_1Definition) {
       definedTags = new Set((root.tags ?? []).map((t) => t.name));
     },
     Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {

package/src/rules/common/security-defined.ts

@@ -9,6 +9,7 @@ import type {
 } from '../../typings/swagger';
 import type {
   Oas3Definition,
+  Oas3_1Definition,
   Oas3Operation,
   Oas3PathItem,
   Oas3SecurityScheme,
@@ -31,7 +32,7 @@ export const SecurityDefined: Oas3Rule | Oas2Rule = (opts: {
 
   return {
     Root: {
-      leave(root: Oas2Definition | Oas3Definition, { report }: UserContext) {
+      leave(root: Oas2Definition | Oas3Definition | Oas3_1Definition, { report }: UserContext) {
         for (const [name, scheme] of referencedSchemes.entries()) {
           if (scheme.defined) continue;
           for (const reportedFromLocation of scheme.from) {

package/src/rules/common/tags-alphabetical.ts

@@ -1,11 +1,14 @@
 import type { Oas3Rule, Oas2Rule } from '../../visitors';
 import type { Oas2Definition, Oas2Tag } from '../../typings/swagger';
-import type { Oas3Definition, Oas3Tag } from '../../typings/openapi';
+import type { Oas3Definition, Oas3Tag, Oas3_1Definition } from '../../typings/openapi';
 import type { UserContext } from '../../walk';
 
 export const TagsAlphabetical: Oas3Rule | Oas2Rule = ({ ignoreCase = false }) => {
   return {
-    Root(root: Oas2Definition | Oas3Definition, { report, location }: UserContext) {
+    Root(
+      root: Oas2Definition | Oas3Definition | Oas3_1Definition,
+      { report, location }: UserContext
+    ) {
       if (!root.tags) return;
       for (let i = 0; i < root.tags.length - 1; i++) {
         if (getTagName(root.tags[i], ignoreCase) > getTagName(root.tags[i + 1], ignoreCase)) {

package/src/rules/oas3/array-parameter-serialization.ts

@@ -12,15 +12,18 @@ export const ArrayParameterSerialization: Oas3Rule = (
 ): Oas3Visitor => {
   return {
     Parameter: {
-      leave(node: Oas3Parameter, ctx) {
+      leave(node, ctx) {
         if (!node.schema) {
           return;
         }
-        const schema = isRef(node.schema)
-          ? ctx.resolve<Oas3_1Schema>(node.schema).node
-          : (node.schema as Oas3_1Schema);
+        const schema = (
+          isRef(node.schema) ? ctx.resolve(node.schema).node : node.schema
+        ) as Oas3_1Schema;
 
-        if (schema && shouldReportMissingStyleAndExplode(node, schema, options)) {
+        if (
+          schema &&
+          shouldReportMissingStyleAndExplode(node as Oas3Parameter<Oas3_1Schema>, schema, options)
+        ) {
           ctx.report({
             message: `Parameter \`${node.name}\` should have \`style\` and \`explode \` fields`,
             location: ctx.location,
@@ -32,7 +35,7 @@ export const ArrayParameterSerialization: Oas3Rule = (
 };
 
 function shouldReportMissingStyleAndExplode(
-  node: Oas3Parameter,
+  node: Oas3Parameter<Oas3_1Schema>,
   schema: Oas3_1Schema,
   options: ArrayParameterSerializationOptions
 ) {

package/src/rules/oas3/component-name-unique.ts

@@ -3,10 +3,12 @@ import type { Problem, UserContext } from '../../walk';
 import type { Oas2Rule, Oas3Rule, Oas3Visitor } from '../../visitors';
 import type {
   Oas3Definition,
+  Oas3_1Definition,
   Oas3Parameter,
   Oas3RequestBody,
   Oas3Response,
   Oas3Schema,
+  Oas3_1Schema,
   OasRef,
 } from '../../typings/openapi';
 
@@ -54,7 +56,7 @@ export const ComponentNameUnique: Oas3Rule | Oas2Rule = (options) => {
       },
     },
     Root: {
-      leave(root: Oas3Definition, ctx: UserContext) {
+      leave(root: Oas3Definition | Oas3_1Definition, ctx: UserContext) {
         components.forEach((value, key, _) => {
           if (value.absolutePointers.size > 1) {
             const component = getComponentFromKey(key);
@@ -82,7 +84,7 @@ export const ComponentNameUnique: Oas3Rule | Oas2Rule = (options) => {
 
   if (options.schemas != 'off') {
     rule.NamedSchemas = {
-      Schema(_: Oas3Schema, { location }: UserContext) {
+      Schema(_: Oas3Schema | Oas3_1Schema, { location }: UserContext) {
         addComponentFromAbsoluteLocation(TYPE_NAME_SCHEMA, location);
       },
     };

package/src/types/arazzo.ts

@@ -84,7 +84,7 @@ const ReusableObject: NodeType = {
 };
 const Parameter: NodeType = {
   properties: {
-    in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+    in: { type: 'string', enum: ['header', 'query', 'path', 'cookie'] },
     name: { type: 'string' },
     value: {}, // any
   },

package/src/types/oas3_1.ts

@@ -182,6 +182,8 @@ export const Schema: NodeType = {
     const: null,
     $comment: { type: 'string' },
     'x-tags': { type: 'array', items: { type: 'string' } },
+    $dynamicAnchor: { type: 'string' },
+    $dynamicRef: { type: 'string' },
   },
   extensionsPrefix: 'x-',
 };

package/src/types/redocly-yaml.ts

@@ -392,10 +392,18 @@ const Rules: NodeType = {
   properties: {},
   additionalProperties: (value: unknown, key: string) => {
     if (key.startsWith('rule/')) {
-      return 'Assert';
+      if (typeof value === 'string') {
+        return { enum: ['error', 'warn', 'off'] };
+      } else {
+        return 'Assert';
+      }
     } else if (key.startsWith('assert/')) {
       // keep the old assert/ prefix as an alias
-      return 'Assert';
+      if (typeof value === 'string') {
+        return { enum: ['error', 'warn', 'off'] };
+      } else {
+        return 'Assert';
+      }
     } else if (builtInRules.includes(key as BuiltInRuleId) || isCustomRuleId(key)) {
       if (typeof value === 'string') {
         return { enum: ['error', 'warn', 'off'] };

package/src/typings/arazzo.ts

@@ -21,7 +21,7 @@ export interface ArazzoSourceDescription {
 export type SourceDescription = OpenAPISourceDescription | ArazzoSourceDescription;
 
 export interface Parameter {
-  in?: 'header' | 'query' | 'path' | 'cookie' | 'body';
+  in?: 'header' | 'query' | 'path' | 'cookie';
   name: string;
   value: string | number | boolean;
   reference?: string;