diff --git a/src/ruleset/index.ts b/src/ruleset/index.ts index f80a62f96..b4197dc0f 100644 --- a/src/ruleset/index.ts +++ b/src/ruleset/index.ts @@ -1,5 +1,6 @@ import { coreRuleset, recommendedRuleset } from './ruleset'; import { v2CoreRuleset, v2SchemasRuleset, v2RecommendedRuleset } from './v2'; +import { v3CoreRuleset } from './v3'; import type { Parser } from '../parser'; import type { RulesetDefinition } from '@stoplight/spectral-core'; @@ -18,6 +19,7 @@ export function createRuleset(parser: Parser, options?: RulesetOptions): Ruleset useCore && v2CoreRuleset, useCore && v2SchemasRuleset(parser), useRecommended && v2RecommendedRuleset, + useCore && v3CoreRuleset, ...(options as any || {})?.extends || [], ].filter(Boolean); diff --git a/src/ruleset/v3/functions/operationMessagesUnambiguity.ts b/src/ruleset/v3/functions/operationMessagesUnambiguity.ts new file mode 100644 index 000000000..75c1d5206 --- /dev/null +++ b/src/ruleset/v3/functions/operationMessagesUnambiguity.ts @@ -0,0 +1,44 @@ +import { createRulesetFunction } from '@stoplight/spectral-core'; +import type { IFunctionResult } from '@stoplight/spectral-core'; +import { SchemaDefinition } from '@stoplight/spectral-core/dist/ruleset/function'; + +const referenceSchema: SchemaDefinition = { + type: 'object', + properties: { + $ref: { + type: 'string', + format: 'uri-reference' + }, + }, +}; + +export const operationMessagesUnambiguity = createRulesetFunction<{ channel?: {'$ref': string}; messages?: [{'$ref': string}] }, null>( + { + input: { + type: 'object', + properties: { + channel: referenceSchema, + messages: { + type: 'array', + items: referenceSchema, + }, + }, + }, + options: null, + }, + (targetVal, _, ctx) => { + const results: IFunctionResult[] = []; + const channelPointer = targetVal.channel?.$ref as string; // required + + targetVal.messages?.forEach((message, index) => { + if (!message.$ref.startsWith(`${channelPointer}/messages`)) { + results.push({ + message: 'Operation message does not belong to the specified channel.', + path: [...ctx.path, 'messages', index], + }); + } + }); + + return results; + }, +); diff --git a/src/ruleset/v3/index.ts b/src/ruleset/v3/index.ts new file mode 100644 index 000000000..5acc4189e --- /dev/null +++ b/src/ruleset/v3/index.ts @@ -0,0 +1 @@ +export * from './ruleset'; diff --git a/src/ruleset/v3/ruleset.ts b/src/ruleset/v3/ruleset.ts new file mode 100644 index 000000000..56f7b6823 --- /dev/null +++ b/src/ruleset/v3/ruleset.ts @@ -0,0 +1,28 @@ +/* eslint-disable sonarjs/no-duplicate-string */ + +import { AsyncAPIFormats } from '../formats'; +import { operationMessagesUnambiguity } from './functions/operationMessagesUnambiguity'; + +export const v3CoreRuleset = { + description: 'Core AsyncAPI 3.x.x ruleset.', + formats: AsyncAPIFormats.filterByMajorVersions(['3']).formats(), + rules: { + /** + * Operation Object rules + */ + 'asyncapi3-operation-messages-from-referred-channel': { + description: 'Operation "messages" must be a subset of the messages defined in the channel referenced in this operation.', + message: '{{error}}', + severity: 'error', + recommended: true, + resolved: false, // We use the JSON pointer to match the channel. + given: [ + '$.operations.*', + '$.components.operations.*', + ], + then: { + function: operationMessagesUnambiguity, + }, + }, + }, +}; diff --git a/test/custom-operations/parse-schema-v3.spec.ts b/test/custom-operations/parse-schema-v3.spec.ts index fab592bde..6e56ed10a 100644 --- a/test/custom-operations/parse-schema-v3.spec.ts +++ b/test/custom-operations/parse-schema-v3.spec.ts @@ -26,7 +26,7 @@ describe('custom operations for v3 - parse schemas', function() { }, messages: [ { - $ref: '#/components/messages/message' + $ref: '#/channels/channel/messages/message' } ] } diff --git a/test/ruleset/rules/v3/asyncapi3-operation-messages-from-referred-channel.spec.ts b/test/ruleset/rules/v3/asyncapi3-operation-messages-from-referred-channel.spec.ts new file mode 100644 index 000000000..fc51d47b5 --- /dev/null +++ b/test/ruleset/rules/v3/asyncapi3-operation-messages-from-referred-channel.spec.ts @@ -0,0 +1,323 @@ +import { testRule, DiagnosticSeverity } from '../../tester'; + +testRule('asyncapi3-operation-messages-from-referred-channel', [ + { + name: 'valid case - required channel', + document: { + asyncapi: '3.0.0', + info: { + title: 'Account Service', + version: '1.0.0' + }, + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + operations: { + UserSignedUp: { + action: 'send', + channel: { + $ref: '#/channels/UserSignedUp' + }, + messages: [ + { + $ref: '#/channels/UserSignedUp/messages/UserSignedUp' + } + ] + } + } + }, + errors: [], + }, + { + name: 'valid case - optional channel', + document: { + asyncapi: '3.0.0', + info: { + title: 'Account Service', + version: '1.0.0' + }, + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + components: { + operations: { + UserSignedUp: { + action: 'send', + channel: { + $ref: '#/channels/UserSignedUp' + }, + messages: [ + { + $ref: '#/channels/UserSignedUp/messages/UserSignedUp' + } + ] + } + }, + } + }, + errors: [], + }, + { + name: 'invalid case - message from operation in root pointing to a message from an optional channel (same name) defined under components', + document: { + asyncapi: '3.0.0', + info: { + title: 'Account Service', + version: '1.0.0' + }, + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + operations: { + UserSignedUp: { + action: 'send', + channel: { + $ref: '#/channels/UserSignedUp' + }, + messages: [ + { + $ref: '#/components/channels/UserSignedUp/messages/UserSignedUp' + } + ] + } + }, + components: { + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + }, + }, + errors: [ + { + message: 'Operation message does not belong to the specified channel.', + path: ['operations', 'UserSignedUp', 'messages', '0'], + severity: DiagnosticSeverity.Error, + } + ], + }, + { + name: 'invalid case - message from operation in components pointing to a message from a different channel defined under components', + document: { + asyncapi: '3.0.0', + info: { + title: 'Account Service', + version: '1.0.0' + }, + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + components: { + channels: { + UserRemoved: { + messages: { + UserRemoved: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + operations: { + UserSignedUp: { + action: 'send', + channel: { + $ref: '#/channels/UserSignedUp' + }, + messages: [ + { + $ref: '#/components/channels/UserRemoved/messages/UserRemoved' + } + ] + } + }, + } + }, + errors: [ + { + message: 'Operation message does not belong to the specified channel.', + path: ['components', 'operations', 'UserSignedUp', 'messages', '0'], + severity: DiagnosticSeverity.Error, + } + ], + }, + { + name: 'invalid case - multiple messages from operation in components pointing to multiple message from a different channel defined under components', + document: { + asyncapi: '3.0.0', + info: { + title: 'Account Service', + version: '1.0.0' + }, + channels: { + UserSignedUp: { + messages: { + UserSignedUp: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + components: { + channels: { + UserRemoved: { + messages: { + UserRemoved: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + }, + UserDeleted: { + payload: { + type: 'object', + properties: { + displayName: { + type: 'string' + }, + email: { + type: 'string' + } + } + } + } + } + } + }, + operations: { + UserSignedUp: { + action: 'send', + channel: { + $ref: '#/channels/UserSignedUp' + }, + messages: [ + { + $ref: '#/components/channels/UserRemoved/messages/UserRemoved' + }, + { + $ref: '#/components/channels/UserRemoved/messages/UserDeleted' + } + ] + } + }, + } + }, + errors: [ + { + message: 'Operation message does not belong to the specified channel.', + path: ['components', 'operations', 'UserSignedUp', 'messages', '0'], + severity: DiagnosticSeverity.Error, + }, + { + message: 'Operation message does not belong to the specified channel.', + path: ['components', 'operations', 'UserSignedUp', 'messages', '1'], + severity: DiagnosticSeverity.Error, + } + ], + }, +]); diff --git a/test/ruleset/tester.ts b/test/ruleset/tester.ts index df08292aa..65c9971b0 100644 --- a/test/ruleset/tester.ts +++ b/test/ruleset/tester.ts @@ -4,6 +4,7 @@ import { AvroSchemaParser } from '@asyncapi/avro-schema-parser'; // allows testi // rulesets import { coreRuleset, recommendedRuleset } from '../../src/ruleset/ruleset'; import { v2CoreRuleset, v2SchemasRuleset, v2RecommendedRuleset } from '../../src/ruleset/v2'; +import { v3CoreRuleset } from '../../src/ruleset/v3'; import type { ParserOptions } from '../../src/parser'; import type { IRuleResult, RulesetDefinition } from '@stoplight/spectral-core'; @@ -15,6 +16,7 @@ type RuleNames = | RulesetRules | RulesetRules | RulesetRules> + | RulesetRules type Scenario = ReadonlyArray< Readonly<{ @@ -51,6 +53,7 @@ function createParser(rules: Array, options: ParserOptions = {}): Par [recommendedRuleset as RulesetDefinition, 'off'], [v2CoreRuleset as RulesetDefinition, 'off'], [v2RecommendedRuleset as RulesetDefinition, 'off'], + [v3CoreRuleset as RulesetDefinition, 'off'], ], rules: { 'asyncapi2-schemas': 'off',