@redocly/openapi-core 1.34.3 → 2.0.0-next.0

package/src/rules/__tests__/no-unresolved-refs.test.ts

@@ -1,271 +0,0 @@
-import path = require('path');
-import { outdent } from 'outdent';
-import { lintDocument } from '../../lint';
-import { BaseResolver } from '../../resolve';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../__tests__/utils';
-
-describe('oas3 boolean-parameter-prefixes', () => {
-  it('should report on unresolved $ref', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        paths:
-          '/test':
-            put:
-              requestBody:
-                $ref: 'invalid.yaml'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/paths/~1test/put/requestBody",
-              "reportOnKey": false,
-              "source": "foobar.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref: ENOENT: no such file or directory 'invalid.yaml'",
-          "ruleId": "no-unresolved-refs",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should report on unresolved $ref yaml error', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        paths:
-          '/test':
-            put:
-              requestBody:
-                $ref: 'fixtures/invalid-yaml.yaml'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": undefined,
-              "reportOnKey": false,
-              "source": "fixtures/invalid-yaml.yaml",
-              "start": {
-                "col": 1,
-                "line": 2,
-              },
-            },
-          ],
-          "message": "Failed to parse: unexpected end of the stream within a single quoted scalar in "fixtures/invalid-yaml.yaml" (2:1)",
-          "ruleId": "no-unresolved-refs",
-          "severity": "error",
-          "suggest": [],
-        },
-        {
-          "location": [
-            {
-              "pointer": "#/paths/~1test/put/requestBody",
-              "reportOnKey": false,
-              "source": "foobar.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref: unexpected end of the stream within a single quoted scalar in "fixtures/invalid-yaml.yaml" (2:1)",
-          "ruleId": "no-unresolved-refs",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should report on unresolved $ref yaml error', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        paths:
-          '/test':
-            put:
-              requestBody:
-                $ref: 'fixtures/ref.yaml'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('should report on unresolved localr ref', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        paths:
-          '/test':
-            put:
-              requestBody:
-                $ref: '#/components/requestBodies/a'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/paths/~1test/put/requestBody",
-              "reportOnKey": false,
-              "source": "foobar.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref",
-          "ruleId": "no-unresolved-refs",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should not report on refs inside specification extensions', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        components:
-          requestBodies:
-            a:
-              content:
-                application/json:
-                  schema:
-                    type: object
-        x-webhooks:
-          test:
-            put:
-              requestBody:
-                $ref: '#/components/requestBodies/a'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('should not report on nested refs inside specification extensions', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        x-test:
-          prop:
-            $ref: 'fixtures/ref.yaml'
-        paths:
-          '/test':
-            get:
-              x-codeSamples:
-                - lang: PHP
-                  source:
-                    $ref: 'fixtures/code-sample.php'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('should not report on nested refs inside specification extensions for 3.1', async () => {
-    const document = parseYamlToDocument(
-      outdent`
-        openapi: 3.1.0
-        x-test:
-          prop:
-            $ref: 'fixtures/ref.yaml'
-        paths:
-          '/test':
-            get:
-              x-codeSamples:
-                - lang: PHP
-                  source:
-                    $ref: 'fixtures/code-sample.php'
-      `,
-      path.join(__dirname, 'foobar.yaml')
-    );
-
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {
-          'no-unresolved-refs': 'error',
-        },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`[]`);
-  });
-});

package/src/rules/__tests__/utils.test.ts

@@ -1,160 +0,0 @@
-import {
-  fieldNonEmpty,
-  matchesJsonSchemaType,
-  missingRequiredField,
-  oasTypeOf,
-  getAdditionalPropertiesOption,
-} from '../utils';
-
-describe('field-non-empty', () => {
-  it('should match expected message', () => {
-    const message = fieldNonEmpty('Car', 'color');
-    expect(message).toBe('Car object `color` must be non-empty string.');
-  });
-});
-
-describe('matches-json-schema-type', () => {
-  it('should report true on a null value with nullable type', () => {
-    const results = matchesJsonSchemaType(null, 'string', true);
-    expect(results).toBe(true);
-  });
-
-  it('should report true on a value and type integer', () => {
-    const results = matchesJsonSchemaType(123, 'integer', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report false when the value is not integer and type is integer', () => {
-    const results = matchesJsonSchemaType(3.14, 'integer', false);
-    expect(results).toBe(false);
-  });
-
-  it('should report true when the value is a number and type is number', () => {
-    const results = matchesJsonSchemaType(3.14, 'number', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report true when the value is an integer and type is number', () => {
-    const results = matchesJsonSchemaType(3, 'number', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report true when the value is true and type is boolean', () => {
-    const results = matchesJsonSchemaType(true, 'boolean', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report true when the value is false and type is boolean', () => {
-    const results = matchesJsonSchemaType(false, 'boolean', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report true when the value is a string and type is boolean', () => {
-    const results = matchesJsonSchemaType('test', 'boolean', false);
-    expect(results).toBe(false);
-  });
-
-  it('should report true on an array value with array type', () => {
-    const results = matchesJsonSchemaType(['foo', 'bar'], 'array', false);
-    expect(results).toBe(true);
-  });
-
-  it('should report false on an array value with object type', () => {
-    const results = matchesJsonSchemaType(['foo', 'bar'], 'object', false);
-    expect(results).toBe(false);
-  });
-
-  it('should report true on an object value with object type', () => {
-    const car = { type: 'Fiat', model: '500', color: 'white' };
-    const results = matchesJsonSchemaType(car, 'object', true);
-    expect(results).toBe(true);
-  });
-
-  it('should report false on an object value with array type', () => {
-    const car = { type: 'Fiat', model: '500', color: 'white' };
-    const results = matchesJsonSchemaType(car, 'array', true);
-    expect(results).toBe(false);
-  });
-});
-
-describe('missing-required-field', () => {
-  it('should match expected message for missing required field', () => {
-    const message = missingRequiredField('Car', 'color');
-    expect(message).toBe('Car object should contain `color` field.');
-  });
-});
-
-describe('oas-type-of', () => {
-  it('should report the correct oas type for a string', () => {
-    const results = oasTypeOf('word');
-    expect(results).toBe('string');
-  });
-
-  it('should report the correct oas type for an integer', () => {
-    const results = oasTypeOf(123);
-    expect(results).toBe('integer');
-  });
-
-  it('should report the correct oas type for a number', () => {
-    const results = oasTypeOf(3.14);
-    expect(results).toBe('number');
-  });
-
-  it('should report the correct oas type for a null value', () => {
-    const results = oasTypeOf(null);
-    expect(results).toBe('null');
-  });
-
-  it('should report the correct oas type for a true boolean', () => {
-    const results = oasTypeOf(true);
-    expect(results).toBe('boolean');
-  });
-
-  it('should report the correct oas type for a false boolean', () => {
-    const results = oasTypeOf(false);
-    expect(results).toBe('boolean');
-  });
-
-  it('should report the correct oas type for an array', () => {
-    const results = oasTypeOf(['foo', 'bar']);
-    expect(results).toBe('array');
-  });
-
-  it('should report the correct oas type for an object', () => {
-    const car = { type: 'Fiat', model: '500', color: 'white' };
-    const results = oasTypeOf(car);
-    expect(results).toBe('object');
-  });
-});
-
-describe('get-additional-properties-option', () => {
-  it('should return actual option', () => {
-    const options = {
-      allowAdditionalProperties: true,
-    };
-    expect(getAdditionalPropertiesOption(options)).toBeTruthy();
-  });
-
-  it('should reverse option', () => {
-    const options = {
-      disallowAdditionalProperties: true,
-    };
-    expect(getAdditionalPropertiesOption(options)).toBeFalsy();
-  });
-
-  it('should throw error with message', () => {
-    const options = {
-      allowAdditionalProperties: true,
-      disallowAdditionalProperties: false,
-    };
-
-    try {
-      getAdditionalPropertiesOption(options);
-    } catch (error) {
-      expect(error).toBeInstanceOf(Error);
-      expect(error.message).toEqual(
-        "Do not use 'disallowAdditionalProperties' field. Use 'allowAdditionalProperties' instead. \n"
-      );
-    }
-  });
-});

package/src/rules/ajv.ts

@@ -1,105 +0,0 @@
-import Ajv from '@redocly/ajv/dist/2020';
-import { escapePointer } from '../ref-utils';
-
-import type { Location } from '../ref-utils';
-import type { ValidateFunction, ErrorObject } from '@redocly/ajv/dist/2020';
-import type { ResolveFn } from '../walk';
-
-let ajvInstance: Ajv | null = null;
-
-export function releaseAjvInstance() {
-  ajvInstance = null;
-}
-
-function getAjv(resolve: ResolveFn, allowAdditionalProperties: boolean) {
-  if (!ajvInstance) {
-    ajvInstance = new Ajv({
-      schemaId: '$id',
-      meta: true,
-      allErrors: true,
-      strictSchema: false,
-      inlineRefs: false,
-      validateSchema: false,
-      discriminator: true,
-      allowUnionTypes: true,
-      validateFormats: false, // TODO: fix it
-      defaultUnevaluatedProperties: allowAdditionalProperties,
-      loadSchemaSync(base: string, $ref: string, $id: string) {
-        const resolvedRef = resolve({ $ref }, base.split('#')[0]);
-        if (!resolvedRef || !resolvedRef.location) return false;
-        return { $id: resolvedRef.location.source.absoluteRef + '#' + $id, ...resolvedRef.node };
-      },
-      logger: false,
-    });
-  }
-  return ajvInstance;
-}
-
-function getAjvValidator(
-  schema: any,
-  loc: Location,
-  resolve: ResolveFn,
-  allowAdditionalProperties: boolean
-): ValidateFunction | undefined {
-  const ajv = getAjv(resolve, allowAdditionalProperties);
-
-  if (!ajv.getSchema(loc.absolutePointer)) {
-    ajv.addSchema({ $id: loc.absolutePointer, ...schema }, loc.absolutePointer);
-  }
-
-  return ajv.getSchema(loc.absolutePointer);
-}
-
-export function validateJsonSchema(
-  data: any,
-  schema: any,
-  schemaLoc: Location,
-  instancePath: string,
-  resolve: ResolveFn,
-  allowAdditionalProperties: boolean
-): { valid: boolean; errors: (ErrorObject & { suggest?: string[] })[] } {
-  const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
-  if (!validate) return { valid: true, errors: [] }; // unresolved refs are reported
-
-  const valid = validate(data, {
-    instancePath,
-    parentData: { fake: {} },
-    parentDataProperty: 'fake',
-    rootData: {},
-    dynamicAnchors: {},
-  });
-
-  return {
-    valid: !!valid,
-    errors: (validate.errors || []).map(beatifyErrorMessage),
-  };
-
-  function beatifyErrorMessage(error: ErrorObject) {
-    let message = error.message;
-    const suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
-    if (suggest) {
-      message += ` ${suggest.map((e: any) => `"${e}"`).join(', ')}`;
-    }
-
-    if (error.keyword === 'type') {
-      message = `type ${message}`;
-    }
-
-    const relativePath = error.instancePath.substring(instancePath.length + 1);
-    const propName = relativePath.substring(relativePath.lastIndexOf('/') + 1);
-    if (propName) {
-      message = `\`${propName}\` property ${message}`;
-    }
-    if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
-      const property = error.params.additionalProperty || error.params.unevaluatedProperty;
-      message = `${message} \`${property}\``;
-      error.instancePath += '/' + escapePointer(property);
-    }
-
-    return {
-      ...error,
-      message,
-      suggest,
-    };
-  }
-}

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

@@ -1,160 +0,0 @@
-import { outdent } from 'outdent';
-import { lintDocument } from '../../../lint';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
-import { BaseResolver } from '../../../resolve';
-
-describe('Arazzo criteria-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: create-event
-              description: >-
-                Create a new special event.
-              operationPath: $sourceDescriptions.museum-api#/paths/~1special-events/post
-              requestBody:
-                payload:
-                  name: 'Mermaid Treasure Identification and Analysis'
-                  location: 'Under the seaaa 🦀 🎶 🌊.'
-                  eventDescription: 'Join us as we review and classify a rare collection of 20 thingamabobs, gadgets, gizmos, whoosits, and whatsits, kindly donated by Ariel.'
-                  dates:
-                    - '2023-09-05'
-                    - '2023-09-08'
-                  price: 0
-              successCriteria:
-                - condition: $statusCode == 200
-                - condition: $statusCode == 200
-                - context: $response.body
-                  condition: $.name == 'Mermaid Treasure Identification and Analysis'
-                  type: jsonpath
-                - context: $response.body
-                  condition: $.name == 'Mermaid Treasure Identification and Analysis'
-                  type: jsonpath
-              onSuccess:
-                - name: 'onSuccessActionName'
-                  type: 'goto'
-                  stepId: 'buy-ticket'
-                  criteria:
-                    - condition: $response.body.open == true
-                    - condition: $response.body.open == true
-              onFailure:
-                - name: 'onFailureActionName'
-                  type: 'goto'
-                  stepId: 'buy-ticket'
-                  criteria:
-                    - condition: $response.body.open == true
-                    - condition: $response.body.open == true
-              outputs:
-                createdEventId: $response.body.eventId
-                name: $response.body.name
-        - workflowId: get-museum-hours-2
-          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 when the duplicated criteria exists', async () => {
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: { 'criteria-unique': 'error' },
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
-      [
-        {
-          "location": [
-            {
-              "pointer": "#/workflows/0/steps/0/successCriteria/1",
-              "reportOnKey": false,
-              "source": "arazzo.yaml",
-            },
-          ],
-          "message": "The Step SuccessCriteria items must be unique.",
-          "ruleId": "criteria-unique",
-          "severity": "error",
-          "suggest": [],
-        },
-        {
-          "location": [
-            {
-              "pointer": "#/workflows/0/steps/0/successCriteria/3",
-              "reportOnKey": false,
-              "source": "arazzo.yaml",
-            },
-          ],
-          "message": "The Step SuccessCriteria items must be unique.",
-          "ruleId": "criteria-unique",
-          "severity": "error",
-          "suggest": [],
-        },
-        {
-          "location": [
-            {
-              "pointer": "#/workflows/0/steps/0/onSuccess/0/criteria/1",
-              "reportOnKey": false,
-              "source": "arazzo.yaml",
-            },
-          ],
-          "message": "The SuccessAction criteria items must be unique.",
-          "ruleId": "criteria-unique",
-          "severity": "error",
-          "suggest": [],
-        },
-        {
-          "location": [
-            {
-              "pointer": "#/workflows/0/steps/0/onFailure/0/criteria/1",
-              "reportOnKey": false,
-              "source": "arazzo.yaml",
-            },
-          ],
-          "message": "The FailureAction criteria items must be unique.",
-          "ruleId": "criteria-unique",
-          "severity": "error",
-          "suggest": [],
-        },
-      ]
-    `);
-  });
-
-  it('should not report when the duplicated criteria exists', async () => {
-    const results = await lintDocument({
-      externalRefResolver: new BaseResolver(),
-      document,
-      config: await makeConfig({
-        rules: {},
-      }),
-    });
-
-    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
-  });
-});