@redocly/openapi-core 1.34.4 → 2.0.0-next.1

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

@@ -1,88 +0,0 @@
-import { outdent } from 'outdent';
-import { lintDocument } from '../../../lint';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { BaseResolver } from '../../../resolve';
-
-describe('Arazzo workflowId-unique', () => {
-  const document = parseYamlToDocument(
-    outdent`
-      arazzo: '1.0.1'
-      info:
-        title: Cool API
-        version: 1.0.0
-        description: A cool API
-      sourceDescriptions:
-        - name: museum-api
-          type: openapi
-          url: openapi.yaml
-      workflows:
-        - workflowId: get-museum-hours
-          description: This workflow demonstrates how to get the museum opening hours and buy tickets.
-          parameters:
-            - in: header
-              name: Authorization
-              value: Basic Og==
-          steps:
-            - stepId: get-museum-hours
-              description: >-
-                Get museum hours by resolving request details with getMuseumHours operationId from openapi.yaml description.
-              operationId: museum-api.getMuseumHours
-              successCriteria:
-                - condition: $statusCode == 200
-        - workflowId: get-museum-hours
-          description: This workflow demonstrates how to get the museum opening hours and buy tickets.
-          parameters:
-            - in: header
-              name: Authorization
-              value: Basic Og==
-          steps:
-            - stepId: get-museum-hours
-              description: >-
-                Get museum hours by resolving request details with getMuseumHours operationId from openapi.yaml description.
-              operationId: museum-api.getMuseumHours
-              successCriteria:
-                - condition: $statusCode == 200
-    `,
-    'arazzo.yaml'
-  );
-
-  it('should report on workflowId unique violation', async () => {
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: { 'workflowId-unique': 'error' },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/workflows/1/get-museum-hours",
-              "reportOnKey": false,
-              "source": "arazzo.yaml",
-            },
-          ],
-          "message": "Every workflow must have a unique \`workflowId\`.",
-          "ruleId": "workflowId-unique",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should not report on workflowId unique violation', async () => {
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: { 'workflowId-unique': 'off' },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-});

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

@@ -1,70 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const CriteriaUnique: Arazzo1Rule = () => {
-  return {
-    FailureActionObject: {
-      enter(action, { report, location }: UserContext) {
-        const criterias = action?.criteria;
-        if (!Array.isArray(criterias)) {
-          return;
-        }
-        const seen = new Set<string>();
-        for (const criteria of criterias) {
-          const key = JSON.stringify(criteria);
-          if (seen.has(key)) {
-            report({
-              message: 'The FailureAction criteria items must be unique.',
-              location: location.child(['criteria', criterias.indexOf(criteria)]),
-            });
-          } else {
-            seen.add(key);
-          }
-        }
-      },
-    },
-    SuccessActionObject: {
-      enter(action, { report, location }: UserContext) {
-        const criterias = action?.criteria;
-        if (!Array.isArray(criterias)) {
-          return;
-        }
-        const seen = new Set<string>();
-        for (const criteria of criterias) {
-          const key = JSON.stringify(criteria);
-          if (seen.has(key)) {
-            report({
-              message: 'The SuccessAction criteria items must be unique.',
-              location: location.child(['criteria', criterias.indexOf(criteria)]),
-            });
-          } else {
-            seen.add(key);
-          }
-        }
-      },
-    },
-    Step: {
-      enter(step, { report, location }: UserContext) {
-        const successCriterias = step?.successCriteria;
-
-        if (!Array.isArray(successCriterias)) {
-          return;
-        }
-
-        const seen = new Set<string>();
-
-        for (const criteria of successCriterias) {
-          const key = JSON.stringify(criteria);
-          if (seen.has(key)) {
-            report({
-              message: 'The Step SuccessCriteria items must be unique.',
-              location: location.child(['successCriteria', successCriterias.indexOf(criteria)]),
-            });
-          } else {
-            seen.add(key);
-          }
-        }
-      },
-    },
-  };
-};

package/src/rules/arazzo/index.ts

@@ -1,38 +0,0 @@
-import { Struct } from '../common/struct';
-import { Assertions } from '../common/assertions';
-import { SourceDescriptionType } from '../arazzo/sourceDescription-type';
-import { SourceDescriptionsNotEmpty } from './sourceDescriptions-not-empty';
-import { RespectSupportedVersions } from '../respect/respect-supported-versions';
-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 { NoCriteriaXpath } from '../respect/no-criteria-xpath';
-import { CriteriaUnique } from './criteria-unique';
-
-import type { Arazzo1Rule } from '../../visitors';
-import type { Arazzo1RuleSet } from '../../oas-types';
-
-export const rules: Arazzo1RuleSet<'built-in'> = {
-  struct: Struct as Arazzo1Rule,
-  assertions: Assertions as Arazzo1Rule,
-  'sourceDescription-type': SourceDescriptionType,
-  'respect-supported-versions': RespectSupportedVersions,
-  'workflowId-unique': WorkflowIdUnique,
-  'stepId-unique': StepIdUnique,
-  'sourceDescription-name-unique': SourceDescriptionsNameUnique,
-  'sourceDescriptions-not-empty': SourceDescriptionsNotEmpty,
-  'workflow-dependsOn': WorkflowDependsOn,
-  'parameters-unique': ParametersUnique,
-  'step-onSuccess-unique': StepOnSuccessUnique,
-  'step-onFailure-unique': StepOnFailureUnique,
-  'requestBody-replacements-unique': RequestBodyReplacementsUnique,
-  'no-criteria-xpath': NoCriteriaXpath,
-  'criteria-unique': CriteriaUnique,
-};
-
-export const preprocessors = {};

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

@@ -1,33 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const ParametersUnique: Arazzo1Rule = () => {
-  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

@@ -1,33 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const RequestBodyReplacementsUnique: Arazzo1Rule = () => {
-  const seenReplacements = new Set();
-
-  return {
-    Step: {
-      leave() {
-        seenReplacements.clear();
-      },
-      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/sourceDescription-type.ts

@@ -1,21 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const SourceDescriptionType: Arazzo1Rule = () => {
-  return {
-    SourceDescriptions: {
-      enter(sourceDescriptions, { report, location }: UserContext) {
-        if (!sourceDescriptions.length) return;
-        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

@@ -1,23 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const SourceDescriptionsNameUnique: Arazzo1Rule = () => {
-  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/sourceDescriptions-not-empty.ts

@@ -1,17 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const SourceDescriptionsNotEmpty: Arazzo1Rule = () => {
-  return {
-    SourceDescriptions: {
-      enter(sourceDescriptions, { report, location }: UserContext) {
-        if (!sourceDescriptions?.length) {
-          report({
-            message: 'The `sourceDescriptions` list must have at least one entry.',
-            location,
-          });
-        }
-      },
-    },
-  };
-};

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

@@ -1,33 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const StepOnFailureUnique: Arazzo1Rule = () => {
-  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

@@ -1,33 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const StepOnSuccessUnique: Arazzo1Rule = () => {
-  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

@@ -1,24 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const StepIdUnique: Arazzo1Rule = () => {
-  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

@@ -1,56 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const WorkflowDependsOn: Arazzo1Rule = () => {
-  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

@@ -1,21 +0,0 @@
-import type { Arazzo1Rule } from '../../visitors';
-import type { UserContext } from '../../walk';
-
-export const WorkflowIdUnique: Arazzo1Rule = () => {
-  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/async2/__tests__/channels-kebab-case.test.ts

@@ -1,145 +0,0 @@
-import { outdent } from 'outdent';
-import { lintDocument } from '../../../lint';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { BaseResolver } from '../../../resolve';
-
-describe('Async2 channels-kebab-case', () => {
-  it('should report on no kebab-case channel path', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        asyncapi: '2.6.0'
-        info:
-          title: Cool API
-          version: 1.0.0
-        channels:
-          NOT_A_KEBAB:
-            subscribe:
-              message:
-                messageId: Message1
-        `,
-      'asyncapi.yaml'
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/channels/NOT_A_KEBAB",
-              "reportOnKey": true,
-              "source": "asyncapi.yaml",
-            },
-          ],
-          "message": "\`NOT_A_KEBAB\` does not use kebab-case.",
-          "ruleId": "channels-kebab-case",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should report on snake_case in channel path', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        asyncapi: '2.6.0'
-        info:
-          title: Cool API
-          version: 1.0.0
-        channels:
-          snake_kebab:
-            subscribe:
-              message:
-                messageId: Message1
-        `,
-      'asyncapi.yaml'
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/channels/snake_kebab",
-              "reportOnKey": true,
-              "source": "asyncapi.yaml",
-            },
-          ],
-          "message": "\`snake_kebab\` does not use kebab-case.",
-          "ruleId": "channels-kebab-case",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should allow trailing slash in channel path with "channels-kebab-case" rule', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        asyncapi: '2.6.0'
-        info:
-          title: Cool API
-          version: 1.0.0
-        channels:
-          kebab/:
-            subscribe:
-              message:
-                messageId: Message1
-        `,
-      'asyncapi.yaml'
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'paths-kebab-case': 'error',
-          'no-path-trailing-slash': 'off',
-        },
-      }),
-    });
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('words with hyphens are allowed with "channels-kebab-case" rule', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        asyncapi: '2.6.0'
-        info:
-          title: Cool API
-          version: 1.0.0
-        channels:
-          kebab-with-longer-channel-path:
-            subscribe:
-              message:
-                messageId: Message1
-        `,
-      'asyncapi.yaml'
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'paths-kebab-case': 'error',
-        },
-      }),
-    });
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-});