@redocly/openapi-core 1.21.1 → 1.22.0

package/src/rules/arazzo/index.ts

@@ -1,6 +1,16 @@
 import { Spec } from '../common/spec';
 import { Assertions } from '../common/assertions';
-import { ParametersNoBodyInsideIn } from '../spot/parameters-no-body-inside-in';
+import { ParametersNotInBody } from '../spot/parameters-not-in-body';
+import { SourceDescriptionType } from '../arazzo/source-description-type';
+import { VersionEnum } from '../spot/version-enum';
+import { WorkflowIdUnique } from './workflowId-unique';
+import { StepIdUnique } from './stepId-unique';
+import { SourceDescriptionsNameUnique } from './sourceDescriptions-name-unique';
+import { WorkflowDependsOn } from './workflow-dependsOn';
+import { ParametersUnique } from './parameters-unique';
+import { StepOnSuccessUnique } from './step-onSuccess-unique';
+import { StepOnFailureUnique } from './step-onFailure-unique';
+import { RequestBodyReplacementsUnique } from './requestBody-replacements-unique';
 
 import type { ArazzoRule } from '../../visitors';
 import type { ArazzoRuleSet } from '../../oas-types';
@@ -8,7 +18,17 @@ import type { ArazzoRuleSet } from '../../oas-types';
 export const rules: ArazzoRuleSet<'built-in'> = {
   spec: Spec as ArazzoRule,
   assertions: Assertions as ArazzoRule,
-  'parameters-no-body-inside-in': ParametersNoBodyInsideIn as ArazzoRule,
+  'parameters-not-in-body': ParametersNotInBody as ArazzoRule,
+  'sourceDescription-type': SourceDescriptionType as ArazzoRule,
+  'version-enum': VersionEnum as ArazzoRule,
+  'workflowId-unique': WorkflowIdUnique as ArazzoRule,
+  'stepId-unique': StepIdUnique as ArazzoRule,
+  'sourceDescription-name-unique': SourceDescriptionsNameUnique as ArazzoRule,
+  'workflow-dependsOn': WorkflowDependsOn as ArazzoRule,
+  'parameters-unique': ParametersUnique as ArazzoRule,
+  'step-onSuccess-unique': StepOnSuccessUnique as ArazzoRule,
+  'step-onFailure-unique': StepOnFailureUnique as ArazzoRule,
+  'requestBody-replacements-unique': RequestBodyReplacementsUnique as ArazzoRule,
 };
 
 export const preprocessors = {};

package/src/rules/arazzo/parameters-unique.ts

@@ -0,0 +1,33 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const ParametersUnique: ArazzoRule = () => {
+  return {
+    Parameters: {
+      enter(parameters, { report, location }: UserContext) {
+        if (!parameters) return;
+        const seenParameters = new Set();
+
+        for (const parameter of parameters) {
+          if (seenParameters.has(parameter?.name)) {
+            report({
+              message: 'The parameter `name` must be unique amongst listed parameters.',
+              location: location.child([parameters.indexOf(parameter)]),
+            });
+          }
+
+          if (seenParameters.has(parameter?.reference)) {
+            report({
+              message: 'The parameter `reference` must be unique amongst listed parameters.',
+              location: location.child([parameters.indexOf(parameter)]),
+            });
+          }
+
+          parameter?.name
+            ? seenParameters.add(parameter.name)
+            : seenParameters.add(parameter.reference);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/requestBody-replacements-unique.ts

@@ -0,0 +1,28 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const RequestBodyReplacementsUnique: ArazzoRule = () => {
+  const seenReplacements = new Set();
+
+  return {
+    RequestBody: {
+      enter(requestBody, { report, location }: UserContext) {
+        if (!requestBody.replacements) return;
+
+        for (const replacement of requestBody.replacements) {
+          if (seenReplacements.has(replacement.target)) {
+            report({
+              message: 'Every `replacement` in `requestBody` must be unique.',
+              location: location.child([
+                'replacements',
+                requestBody.replacements.indexOf(replacement),
+                `target`,
+              ]),
+            });
+          }
+          seenReplacements.add(replacement.target);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/source-description-type.ts

@@ -0,0 +1,20 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const SourceDescriptionType: ArazzoRule = () => {
+  return {
+    SourceDescriptions: {
+      enter(SourceDescriptions, { report, location }: UserContext) {
+        for (const sourceDescription of SourceDescriptions) {
+          if (!['openapi', 'arazzo'].includes(sourceDescription?.type)) {
+            report({
+              message:
+                'The `type` property of the `sourceDescription` object must be either `openapi` or `arazzo`.',
+              location: location.child([SourceDescriptions.indexOf(sourceDescription)]),
+            });
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/sourceDescriptions-name-unique.ts

@@ -0,0 +1,23 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const SourceDescriptionsNameUnique: ArazzoRule = () => {
+  const seenSourceDescriptions = new Set();
+
+  return {
+    SourceDescriptions: {
+      enter(sourceDescriptions, { report, location }: UserContext) {
+        if (!sourceDescriptions.length) return;
+        for (const sourceDescription of sourceDescriptions) {
+          if (seenSourceDescriptions.has(sourceDescription.name)) {
+            report({
+              message: 'The `name` must be unique amongst all SourceDescriptions.',
+              location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+            });
+          }
+          seenSourceDescriptions.add(sourceDescription.name);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/step-onFailure-unique.ts

@@ -0,0 +1,33 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const StepOnFailureUnique: ArazzoRule = () => {
+  return {
+    OnFailureActionList: {
+      enter(onFailureActionList, { report, location }: UserContext) {
+        if (!onFailureActionList) return;
+        const seenFailureActions = new Set();
+
+        for (const onFailureAction of onFailureActionList) {
+          if (seenFailureActions.has(onFailureAction?.name)) {
+            report({
+              message: 'The action `name` must be unique amongst listed `onFailure` actions.',
+              location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+            });
+          }
+
+          if (seenFailureActions.has(onFailureAction?.reference)) {
+            report({
+              message: 'The action `reference` must be unique amongst listed `onFailure` actions.',
+              location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+            });
+          }
+
+          onFailureAction?.name
+            ? seenFailureActions.add(onFailureAction.name)
+            : seenFailureActions.add(onFailureAction.reference);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/step-onSuccess-unique.ts

@@ -0,0 +1,33 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const StepOnSuccessUnique: ArazzoRule = () => {
+  return {
+    OnSuccessActionList: {
+      enter(onSuccessActionList, { report, location }: UserContext) {
+        if (!onSuccessActionList) return;
+        const seenSuccessActions = new Set();
+
+        for (const onSuccessAction of onSuccessActionList) {
+          if (seenSuccessActions.has(onSuccessAction?.name)) {
+            report({
+              message: 'The action `name` must be unique amongst listed `onSuccess` actions.',
+              location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+            });
+          }
+
+          if (seenSuccessActions.has(onSuccessAction?.reference)) {
+            report({
+              message: 'The action `reference` must be unique amongst listed `onSuccess` actions.',
+              location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+            });
+          }
+
+          onSuccessAction?.name
+            ? seenSuccessActions.add(onSuccessAction.name)
+            : seenSuccessActions.add(onSuccessAction.reference);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/stepId-unique.ts

@@ -0,0 +1,24 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const StepIdUnique: ArazzoRule = () => {
+  return {
+    Workflow: {
+      enter(workflow, { report, location }: UserContext) {
+        if (!workflow.steps) return;
+        const seenSteps = new Set();
+
+        for (const step of workflow.steps) {
+          if (!step.stepId) return;
+          if (seenSteps.has(step.stepId)) {
+            report({
+              message: 'The `stepId` must be unique amongst all steps described in the workflow.',
+              location: location.child(['steps', workflow.steps.indexOf(step)]),
+            });
+          }
+          seenSteps.add(step.stepId);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/workflow-dependsOn.ts

@@ -0,0 +1,56 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const WorkflowDependsOn: ArazzoRule = () => {
+  const seenWorkflow = new Set();
+  const existingSourceDescriptions = new Set();
+  const existingWorkflowIds = new Set();
+
+  return {
+    SourceDescriptions: {
+      enter(sourceDescriptions) {
+        for (const sourceDescription of sourceDescriptions) {
+          existingSourceDescriptions.add(sourceDescription.name);
+        }
+      },
+    },
+    Workflows: {
+      enter(workflows) {
+        for (const workflow of workflows) {
+          existingWorkflowIds.add(workflow.workflowId);
+        }
+      },
+    },
+    Workflow: {
+      leave(workflow, { report, location }: UserContext) {
+        if (!workflow.dependsOn) return;
+
+        for (const item of workflow.dependsOn) {
+          // Possible dependsOn workflow pattern: $sourceDescriptions.<name>.<workflowId>
+          if (item.startsWith('$sourceDescriptions.')) {
+            const sourceDescriptionName = item.split('.')[1];
+            if (!existingSourceDescriptions.has(sourceDescriptionName)) {
+              report({
+                message: `SourceDescription ${sourceDescriptionName} must be defined in sourceDescriptions.`,
+                location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+              });
+            }
+          }
+          if (!item.startsWith('$sourceDescriptions') && !existingWorkflowIds.has(item)) {
+            report({
+              message: `Workflow ${item} must be defined in workflows.`,
+              location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+            });
+          }
+          if (seenWorkflow.has(item)) {
+            report({
+              message: 'Every workflow in dependsOn must be unique.',
+              location: location.child([`dependsOn`]),
+            });
+          }
+          seenWorkflow.add(item);
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/workflowId-unique.ts

@@ -0,0 +1,21 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const WorkflowIdUnique: ArazzoRule = () => {
+  const seenWorkflow = new Set();
+
+  return {
+    Workflow: {
+      enter(workflow, { report, location }: UserContext) {
+        if (!workflow.workflowId) return;
+        if (seenWorkflow.has(workflow.workflowId)) {
+          report({
+            message: 'Every workflow must have a unique `workflowId`.',
+            location: location.child([workflow.workflowId]),
+          });
+        }
+        seenWorkflow.add(workflow.workflowId);
+      },
+    },
+  };
+};

package/src/rules/spot/{parameters-no-body-inside-in.ts → parameters-not-in-body.ts}

@@ -1,7 +1,7 @@
 import type { ArazzoRule } from '../../visitors';
 import type { UserContext } from '../../walk';
 
-export const ParametersNoBodyInsideIn: ArazzoRule = () => {
+export const ParametersNotInBody: ArazzoRule = () => {
   return {
     Parameter: {
       enter(parameter, { report, location }: UserContext) {

package/src/rules/spot/version-enum.ts

@@ -0,0 +1,24 @@
+import { ARAZZO_VERSIONS_SUPPORTED_BY_SPOT } from '../../typings/arazzo';
+import { pluralize } from '../../utils';
+
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const VersionEnum: ArazzoRule = () => {
+  const supportedVersions = ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.join(', ');
+  return {
+    Root: {
+      enter(root, { report, location }: UserContext) {
+        if (!ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.includes(root.arazzo)) {
+          report({
+            message: `Only ${supportedVersions} Arazzo ${pluralize(
+              'version is',
+              ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.length
+            )} supported by Spot.`,
+            location: location.child('arazzo'),
+          });
+        }
+      },
+    },
+  };
+};

package/src/types/arazzo.ts

@@ -4,7 +4,7 @@ import { Discriminator, DiscriminatorMapping, ExternalDocs, Xml } from './oas3';
 
 const Root: NodeType = {
   properties: {
-    arazzo: { type: 'string', enum: ['1.0.0'] },
+    arazzo: { type: 'string' },
     info: 'Info',
     sourceDescriptions: 'SourceDescriptions',
     'x-parameters': 'Parameters',
@@ -89,9 +89,7 @@ const ArazzoSourceDescription: NodeType = {
 const ReusableObject: NodeType = {
   properties: {
     reference: { type: 'string' },
-    value: {
-      type: 'string',
-    },
+    value: {}, // any
   },
   required: ['reference'],
   extensionsPrefix: 'x-',
@@ -108,10 +106,10 @@ const Parameter: NodeType = {
 const Parameters: NodeType = {
   properties: {},
   items: (value: any) => {
-    if (value?.in) {
-      return 'Parameter';
-    } else {
+    if (value?.reference) {
       return 'ReusableObject';
+    } else {
+      return 'Parameter';
     }
   },
 };
@@ -122,7 +120,7 @@ const Workflow: NodeType = {
     description: { type: 'string' },
     parameters: 'Parameters',
     dependsOn: { type: 'array', items: { type: 'string' } },
-    inputs: 'NamedInputs',
+    inputs: 'Schema',
     outputs: 'Outputs',
     steps: 'Steps',
     successActions: 'OnSuccessActionList',
@@ -234,7 +232,7 @@ const SuccessActionObject: NodeType = {
     type: { type: 'string', enum: ['goto', 'end'] },
     stepId: { type: 'string' },
     workflowId: { type: 'string' },
-    criteria: 'CriterionObject',
+    criteria: listOf('CriterionObject'),
   },
   required: ['type', 'name'],
 };
@@ -256,7 +254,7 @@ const FailureActionObject: NodeType = {
     stepId: { type: 'string' },
     retryAfter: { type: 'number' },
     retryLimit: { type: 'number' },
-    criteria: 'CriterionObject',
+    criteria: listOf('CriterionObject'),
   },
   required: ['type', 'name'],
 };

package/src/types/redocly-yaml.ts

@@ -109,7 +109,20 @@ export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
 export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
 
-const builtInArazzoRules = ['spec', 'parameters-no-body-inside-in'] as const;
+const builtInArazzoRules = [
+  'spec',
+  'parameters-not-in-body',
+  'sourceDescription-type',
+  'version-enum',
+  'workflowId-unique',
+  'stepId-unique',
+  'sourceDescription-name-unique',
+  'workflow-dependsOn',
+  'parameters-unique',
+  'step-onSuccess-unique',
+  'step-onFailure-unique',
+  'requestBody-replacements-unique',
+] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
 

package/src/typings/arazzo.ts

@@ -170,3 +170,7 @@ export interface ArazzoDefinition {
     };
   };
 }
+
+export const VERSION_PATTERN = /^1\.0\.\d+(-.+)?$/;
+
+export const ARAZZO_VERSIONS_SUPPORTED_BY_SPOT = ['1.0.0'];

package/src/utils.ts

@@ -6,6 +6,7 @@ import { parseYaml } from './js-yaml';
 import { env } from './env';
 import { logger, colorize } from './logger';
 import { HttpsProxyAgent } from 'https-proxy-agent';
+import * as pluralizeOne from 'pluralize';
 
 import type { HttpResolveConfig } from './config';
 import type { UserContext } from './walk';
@@ -23,6 +24,13 @@ export function pushStack<T, P extends Stack<T> = Stack<T>>(head: P, value: T) {
   return { prev: head, value };
 }
 
+export function pluralize(sentence: string, count?: number, inclusive?: boolean) {
+  return sentence
+    .split(' ')
+    .map((word) => pluralizeOne(word, count, inclusive))
+    .join(' ');
+}
+
 export function popStack<T, P extends Stack<T>>(head: P) {
   return head?.prev ?? null;
 }