@redocly/openapi-core 1.18.0 → 1.19.0

package/src/rules/async3/__tests__/no-channel-trailing-slash.test.ts

@@ -0,0 +1,96 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('no-channel-trailing-slash', () => {
+  it.only('should report on trailing slash in a channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+              address: /trailing/
+              payload:
+                type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/channels/channel1",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`/trailing/\` should not have a trailing slash.",
+          "ruleId": "no-channel-trailing-slash",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on if no trailing slash in path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+            address: /expected
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('should not report on trailing slash in path if the path is root', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+            address: /
+            payload:
+              type: object
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+});

package/src/rules/async3/channels-kebab-case.ts

@@ -0,0 +1,19 @@
+import { Channel } from '../../typings/asyncapi3';
+import { Async3Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const ChannelsKebabCase: Async3Rule = () => {
+  return {
+    Channel(channel: Channel, { report }: UserContext) {
+      const segments = (channel.address || '')
+        .split(/[/.:]/) // split on / or : as likely channel namespacers
+        .filter((s) => s !== ''); // filter out empty segments
+      if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+        report({
+          message: `\`${channel.address}\` does not use kebab-case.`,
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/async3/index.ts

@@ -0,0 +1,23 @@
+import { Async3Rule } from '../../visitors';
+import { Assertions } from '../common/assertions';
+import { Spec } from '../common/spec';
+import { InfoContact } from '../common/info-contact';
+import { OperationOperationId } from '../common/operation-operationId';
+import { TagDescription } from '../common/tag-description';
+import { TagsAlphabetical } from '../common/tags-alphabetical';
+import { ChannelsKebabCase } from './channels-kebab-case';
+import { NoChannelTrailingSlash } from './no-channel-trailing-slash';
+import type { Async3RuleSet } from '../../oas-types';
+
+export const rules: Async3RuleSet<'built-in'> = {
+  spec: Spec as Async3Rule,
+  assertions: Assertions as Async3Rule,
+  'info-contact': InfoContact as Async3Rule,
+  'operation-operationId': OperationOperationId as Async3Rule,
+  'channels-kebab-case': ChannelsKebabCase,
+  'no-channel-trailing-slash': NoChannelTrailingSlash,
+  'tag-description': TagDescription as Async3Rule,
+  'tags-alphabetical': TagsAlphabetical as Async3Rule,
+};
+
+export const preprocessors = {};

package/src/rules/async3/no-channel-trailing-slash.ts

@@ -0,0 +1,16 @@
+import { Async3Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { Channel } from '../../typings/asyncapi3';
+
+export const NoChannelTrailingSlash: Async3Rule = () => {
+  return {
+    Channel(channel: Channel, { report, location }: UserContext) {
+      if ((channel.address as string).endsWith('/') && channel.address !== '/') {
+        report({
+          message: `\`${channel.address}\` should not have a trailing slash.`,
+          location: location.key(),
+        });
+      }
+    },
+  };
+};

package/src/rules/common/__tests__/spec.test.ts

@@ -607,4 +607,51 @@ describe('Oas3.1 spec', () => {
       ]
     `);
   });
+
+  it('should flag invalid dependentSchemas', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.1.0
+      info:
+        version: 1.0.0
+        title: Example.com
+        description: info,
+        license:
+          name: Apache 2.0
+          url: 'http://www.apache.org/licenses/LICENSE-2.0.html'
+      components:
+        schemas:
+          withInvalidDependentSchemas:
+            dependentSchemas:
+              - invalid1
+              - invalid2
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "from": undefined,
+          "location": [
+            {
+              "pointer": "#/components/schemas/withInvalidDependentSchemas/dependentSchemas",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Expected type \`SchemaMap\` (object) but got \`array\`",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
 });

package/src/rules/common/assertions/index.ts

@@ -1,9 +1,17 @@
-import { asserts, AssertionFn } from './asserts';
+import { asserts } from './asserts';
 import { buildSubjectVisitor, buildVisitorObject } from './utils';
-import { Oas2Visitor, Oas3Visitor } from '../../../visitors';
-import { RuleSeverity } from '../../../config';
 import { isString } from '../../../utils';
 
+import type { AssertionFn } from './asserts';
+import type {
+  ArazzoVisitor,
+  Async2Visitor,
+  Async3Visitor,
+  Oas2Visitor,
+  Oas3Visitor,
+} from '../../../visitors';
+import type { RuleSeverity } from '../../../config';
+
 export type AssertionLocators = {
   filterInParentKeys?: (string | number)[];
   filterOutParentKeys?: (string | number)[];
@@ -28,7 +36,8 @@ export type RawAssertion = AssertionDefinition & {
 export type Assertion = RawAssertion & { assertionId: string };
 
 export const Assertions = (opts: Record<string, Assertion>) => {
-  const visitors: (Oas2Visitor | Oas3Visitor)[] = [];
+  const visitors: (Oas2Visitor | Oas3Visitor | Async2Visitor | Async3Visitor | ArazzoVisitor)[] =
+    [];
 
   // As 'Assertions' has an array of asserts,
   // that array spreads into an 'opts' object on init rules phase here

package/src/rules/common/no-invalid-schema-examples.ts

@@ -1,7 +1,8 @@
-import { UserContext } from '../../walk';
-import { Oas3_1Schema } from '../../typings/openapi';
 import { getAdditionalPropertiesOption, validateExample } from '../utils';
 
+import type { UserContext } from '../../walk';
+import type { Oas3_1Schema } from '../../typings/openapi';
+
 export const NoInvalidSchemaExamples: any = (opts: any) => {
   const allowAdditionalProperties = getAdditionalPropertiesOption(opts) ?? false;
   return {

package/src/rules/common/path-segment-plural.ts

@@ -1,6 +1,7 @@
+import * as pluralize from 'pluralize';
 import { Oas3Rule, Oas2Rule } from '../../visitors';
 import { UserContext } from '../../walk';
-import { isPathParameter, isSingular } from '../../utils';
+import { isPathParameter } from '../../utils';
 
 export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
   const { ignoreLastPathSegment, exceptions } = opts;
@@ -17,7 +18,7 @@ export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
 
           for (const pathSegment of pathSegments) {
             if (exceptions && exceptions.includes(pathSegment)) continue;
-            if (!isPathParameter(pathSegment) && isSingular(pathSegment)) {
+            if (!isPathParameter(pathSegment) && pluralize.isSingular(pathSegment)) {
               report({
                 message: `path segment \`${pathSegment}\` should be plural.`,
                 location: location.key(),

package/src/rules/common/spec.ts

@@ -1,11 +1,11 @@
-import type { Oas3Rule, Oas2Rule, Async2Rule, ArazzoRule } from '../../visitors';
+import type { Oas3Rule, Oas2Rule, Async2Rule, Async3Rule, ArazzoRule } from '../../visitors';
 import { isNamedType, SpecExtension } from '../../types';
 import { oasTypeOf, matchesJsonSchemaType, getSuggest, validateSchemaEnumType } from '../utils';
 import { isRef } from '../../ref-utils';
 import { isPlainObject } from '../../utils';
 import { UserContext } from '../../walk';
 
-export const Spec: Oas3Rule | Oas2Rule | Async2Rule | ArazzoRule = () => {
+export const Spec: Oas3Rule | Oas2Rule | Async2Rule | Async3Rule | ArazzoRule = () => {
   return {
     any(
       node: any,

package/src/rules/oas2/index.ts

@@ -86,10 +86,10 @@ export const rules: Oas2RuleSet<'built-in'> = {
   'path-segment-plural': PathSegmentPlural as Oas2Rule,
   'response-contains-header': ResponseContainsHeader as Oas2Rule,
   'response-contains-property': ResponseContainsProperty as Oas2Rule,
-  'scalar-property-missing-example': ScalarPropertyMissingExample,
-  'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength,
-  'spec-strict-refs': SpecStrictRefs,
-  'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
+  'scalar-property-missing-example': ScalarPropertyMissingExample as Oas2Rule,
+  'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength as Oas2Rule,
+  'spec-strict-refs': SpecStrictRefs as Oas2Rule,
+  'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined as Oas2Rule,
 };
 
 export const preprocessors = {};

package/src/rules/oas3/index.ts

@@ -55,63 +55,65 @@ import { ComponentNameUnique } from './component-name-unique';
 import { ArrayParameterSerialization } from './array-parameter-serialization';
 import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined';
 
+import type { Oas3Rule } from '../../visitors';
+
 export const rules: Oas3RuleSet<'built-in'> = {
-  spec: Spec,
-  'info-contact': InfoContact,
-  'info-license': InfoLicense,
-  'info-license-url': InfoLicenseUrl,
-  'operation-2xx-response': Operation2xxResponse,
-  'operation-4xx-response': Operation4xxResponse,
+  spec: Spec as Oas3Rule,
+  'info-contact': InfoContact as Oas3Rule,
+  'info-license': InfoLicense as Oas3Rule,
+  'info-license-url': InfoLicenseUrl as Oas3Rule,
+  'operation-2xx-response': Operation2xxResponse as Oas3Rule,
+  'operation-4xx-response': Operation4xxResponse as Oas3Rule,
   'operation-4xx-problem-details-rfc7807': Operation4xxProblemDetailsRfc7807,
-  assertions: Assertions,
-  'operation-operationId-unique': OperationIdUnique,
-  'operation-parameters-unique': OperationParametersUnique,
-  'operation-tag-defined': OperationTagDefined,
+  assertions: Assertions as Oas3Rule,
+  'operation-operationId-unique': OperationIdUnique as Oas3Rule,
+  'operation-parameters-unique': OperationParametersUnique as Oas3Rule,
+  'operation-tag-defined': OperationTagDefined as Oas3Rule,
   'no-example-value-and-externalValue': NoExampleValueAndExternalValue,
-  'no-enum-type-mismatch': NoEnumTypeMismatch,
-  'no-path-trailing-slash': NoPathTrailingSlash,
+  'no-enum-type-mismatch': NoEnumTypeMismatch as Oas3Rule,
+  'no-path-trailing-slash': NoPathTrailingSlash as Oas3Rule,
   'no-empty-servers': NoEmptyServers,
-  'path-declaration-must-exist': PathDeclarationMustExist,
-  'operation-operationId-url-safe': OperationIdUrlSafe,
-  'operation-operationId': OperationOperationId,
-  'operation-summary': OperationSummary,
-  'tags-alphabetical': TagsAlphabetical,
+  'path-declaration-must-exist': PathDeclarationMustExist as Oas3Rule,
+  'operation-operationId-url-safe': OperationIdUrlSafe as Oas3Rule,
+  'operation-operationId': OperationOperationId as Oas3Rule,
+  'operation-summary': OperationSummary as Oas3Rule,
+  'tags-alphabetical': TagsAlphabetical as Oas3Rule,
   'no-server-example.com': NoServerExample,
   'no-server-trailing-slash': NoServerTrailingSlash,
-  'tag-description': TagDescription,
-  'operation-description': OperationDescription,
+  'tag-description': TagDescription as Oas3Rule,
+  'operation-description': OperationDescription as Oas3Rule,
   'no-unused-components': NoUnusedComponents,
-  'path-not-include-query': PathNotIncludeQuery,
-  'path-parameters-defined': PathParamsDefined,
-  'path-params-defined': PathParamsDefined,
-  'parameter-description': ParameterDescription,
-  'operation-singular-tag': OperationSingularTag,
-  'security-defined': SecurityDefined,
+  'path-not-include-query': PathNotIncludeQuery as Oas3Rule,
+  'path-parameters-defined': PathParamsDefined as Oas3Rule,
+  'path-params-defined': PathParamsDefined as Oas3Rule,
+  'parameter-description': ParameterDescription as Oas3Rule,
+  'operation-singular-tag': OperationSingularTag as Oas3Rule,
+  'security-defined': SecurityDefined as Oas3Rule,
   'no-unresolved-refs': NoUnresolvedRefs,
-  'paths-kebab-case': PathsKebabCase,
+  'paths-kebab-case': PathsKebabCase as Oas3Rule,
   'boolean-parameter-prefixes': BooleanParameterPrefixes,
-  'path-http-verbs-order': PathHttpVerbsOrder,
+  'path-http-verbs-order': PathHttpVerbsOrder as Oas3Rule,
   'no-invalid-media-type-examples': ValidContentExamples,
-  'no-identical-paths': NoIdenticalPaths,
-  'no-ambiguous-paths': NoAmbiguousPaths,
+  'no-identical-paths': NoIdenticalPaths as Oas3Rule,
+  'no-ambiguous-paths': NoAmbiguousPaths as Oas3Rule,
   'no-undefined-server-variable': NoUndefinedServerVariable,
   'no-server-variables-empty-enum': NoServerVariablesEmptyEnum,
-  'no-http-verbs-in-paths': NoHttpVerbsInPaths,
-  'path-excludes-patterns': PathExcludesPatterns,
+  'no-http-verbs-in-paths': NoHttpVerbsInPaths as Oas3Rule,
+  'path-excludes-patterns': PathExcludesPatterns as Oas3Rule,
   'request-mime-type': RequestMimeType,
   'response-mime-type': ResponseMimeType,
-  'path-segment-plural': PathSegmentPlural,
+  'path-segment-plural': PathSegmentPlural as Oas3Rule,
   'no-invalid-schema-examples': NoInvalidSchemaExamples,
   'no-invalid-parameter-examples': NoInvalidParameterExamples,
-  'response-contains-header': ResponseContainsHeader,
+  'response-contains-header': ResponseContainsHeader as Oas3Rule,
   'response-contains-property': ResponseContainsProperty,
-  'scalar-property-missing-example': ScalarPropertyMissingExample,
+  'scalar-property-missing-example': ScalarPropertyMissingExample as Oas3Rule,
   'spec-components-invalid-map-name': SpecComponentsInvalidMapName,
   'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength,
-  'spec-strict-refs': SpecStrictRefs,
-  'component-name-unique': ComponentNameUnique,
+  'spec-strict-refs': SpecStrictRefs as Oas3Rule,
+  'component-name-unique': ComponentNameUnique as Oas3Rule,
   'array-parameter-serialization': ArrayParameterSerialization,
-  'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
+  'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined as Oas3Rule,
 };
 
 export const preprocessors = {};

package/src/types/arazzo.ts

@@ -4,11 +4,11 @@ import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 
 export const ARAZZO_ROOT_TYPE = 'Root';
 
-const operationMethod = {
+export const operationMethod = {
   type: 'string',
   enum: ['get', 'post', 'put', 'delete', 'patch'],
 } as const;
-const expectSchema = {
+export const expectSchema = {
   type: 'object',
   properties: {
     statusCode: { type: 'number' },
@@ -58,7 +58,7 @@ const arazzoSourceDescriptionSchema = {
   additionalProperties: false,
   required: ['name', 'type', 'url'],
 } as const;
-const sourceDescriptionSchema = {
+export const sourceDescriptionSchema = {
   type: 'object',
   oneOf: [
     openAPISourceDescriptionSchema,
@@ -81,7 +81,7 @@ const extendedOperation = {
   additionalProperties: false,
   required: ['path', 'method'],
 } as const;
-const parameter = {
+export const parameter = {
   type: 'object',
   oneOf: [
     {
@@ -96,17 +96,6 @@ const parameter = {
       required: ['name', 'value'],
       additionalProperties: false,
     },
-    {
-      type: 'object',
-      properties: {
-        $ref: { type: 'string' },
-        value: {
-          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
-        },
-      },
-      required: ['$ref'],
-      additionalProperties: false,
-    },
     {
       type: 'object',
       properties: {
@@ -124,7 +113,7 @@ const parameters = {
   type: 'array',
   items: parameter,
 } as const;
-const infoObject = {
+export const infoObject = {
   type: 'object',
   properties: {
     title: { type: 'string' },
@@ -135,7 +124,7 @@ const infoObject = {
   additionalProperties: false,
   required: ['title', 'version'],
 } as const;
-const replacement = {
+export const replacement = {
   type: 'object',
   properties: {
     target: { type: 'string' },
@@ -150,7 +139,7 @@ const replacement = {
     },
   },
 } as const;
-const requestBody = {
+export const requestBody = {
   type: 'object',
   properties: {
     contentType: { type: 'string' },
@@ -172,7 +161,7 @@ const requestBody = {
   additionalProperties: false,
   required: ['payload'],
 } as const;
-const criteriaObject = {
+export const criteriaObject = {
   type: 'object',
   properties: {
     condition: { type: 'string' },
@@ -204,7 +193,7 @@ const criteriaObjects = {
   type: 'array',
   items: criteriaObject,
 } as const;
-const inherit = {
+export const inherit = {
   type: 'string',
   enum: ['auto', 'none'],
 } as const;
@@ -242,7 +231,7 @@ const onFailureList = {
   type: 'array',
   items: onFailureObject,
 } as const;
-const step = {
+export const step = {
   type: 'object',
   properties: {
     stepId: { type: 'string' },
@@ -257,7 +246,23 @@ const step = {
     outputs: {
       type: 'object',
       additionalProperties: {
-        type: 'string',
+        oneOf: [
+          {
+            type: 'string',
+          },
+          {
+            type: 'object',
+          },
+          {
+            type: 'array',
+          },
+          {
+            type: 'boolean',
+          },
+          {
+            type: 'number',
+          },
+        ],
       },
     },
     'x-inherit': inherit,
@@ -301,7 +306,7 @@ const JSONSchema = {
   required: ['type'],
   additionalProperties: true,
 } as const;
-const workflow = {
+export const workflow = {
   type: 'object',
   properties: {
     workflowId: { type: 'string' },