@redocly/openapi-core 1.0.0-beta.100

package/src/rules/ajv.ts

@@ -0,0 +1,103 @@
+import Ajv, { ValidateFunction, ErrorObject } from '@redocly/ajv';
+import { Location, escapePointer } from '../ref-utils';
+import { ResolveFn } from '../walk';
+
+let ajvInstance: Ajv | null = null;
+
+export function releaseAjvInstance() {
+  ajvInstance = null;
+}
+
+function getAjv(resolve: ResolveFn<any>, disallowAdditionalProperties: 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
+      defaultAdditionalProperties: !disallowAdditionalProperties,
+      loadSchemaSync(base: string, $ref: string) {
+        const resolvedRef = resolve({ $ref }, base.split('#')[0]);
+        if (!resolvedRef || !resolvedRef.location) return undefined;
+        return { $id: resolvedRef.location.absolutePointer, ...resolvedRef.node };
+      },
+      logger: false,
+    });
+  }
+  return ajvInstance;
+}
+
+function getAjvValidator(
+  schema: any,
+  loc: Location,
+  resolve: ResolveFn<any>,
+  disallowAdditionalProperties: boolean,
+): ValidateFunction | undefined {
+  const ajv = getAjv(resolve, disallowAdditionalProperties);
+
+  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<any>,
+  disallowAdditionalProperties: boolean,
+): { valid: boolean; errors: (ErrorObject & { suggest?: string[] })[] } {
+  const validate = getAjvValidator(schema, schemaLoc, resolve, disallowAdditionalProperties);
+  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;
+    let 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') {
+      const property = error.params.additionalProperty;
+      message = `${message} \`${property}\``;
+      error.instancePath += '/' + escapePointer(property);
+    }
+
+    return {
+      ...error,
+      message,
+      suggest,
+    };
+  }
+}

package/src/rules/common/__tests__/info-description.test.ts

@@ -0,0 +1,102 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 info-description', () => {
+  it('should report on info with no description', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            version: '1.0'
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'info-description': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info/description",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Info object should contain \`description\` field.",
+          "ruleId": "info-description",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on info with empty description', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            version: '1.0'
+            description: ''
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'info-description': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info/description",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Info object \`description\` must be non-empty string.",
+          "ruleId": "info-description",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info with description', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            description: test description
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'info-description': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/common/__tests__/info-license.test.ts

@@ -0,0 +1,62 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 info-license', () => {
+  it('should report on info with no license', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            version: '1.0'
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Info object should contain \`license\` field.",
+          "ruleId": "info-license",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info with license', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+              url: google.com
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/common/__tests__/license-url.test.ts

@@ -0,0 +1,63 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 license-url', () => {
+  it('should report on info.license with no url', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license-url': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info/license/url",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "License object should contain \`url\` field.",
+          "ruleId": "info-license-url",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info.license with url', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+              url: google.com
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license-url': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/common/__tests__/no-ambiguous-paths.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-ambiguous-paths', () => {
+  it('should report on ambiguous paths', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/good/{id}':
+            get:
+              summary: List all pets
+          '/good/last':
+            get:
+              summary: List all pets
+          '/good/{id}/{pet}':
+            get:
+              summary: List all pets
+          '/good/last/{id}':
+            get:
+              summary: List all pets
+          '/{id}/ambiguous':
+            get:
+              summary: List all pets
+          '/ambiguous/{id}':
+            get:
+              summary: List all pets
+          '/pet/last':
+            get:
+              summary: List all pets
+          '/pet/first':
+            get:
+              summary: List all pets
+          '/{entity}/{id}/last':
+            get:
+              summary: List all pets
+          '/pet/first/{id}':
+            get:
+              summary: List all pets
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-ambiguous-paths': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1{id}~1ambiguous",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Paths should resolve unambiguously. Found two ambiguous paths: \`/good/{id}\` and \`/{id}/ambiguous\`.",
+          "ruleId": "no-ambiguous-paths",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1ambiguous~1{id}",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Paths should resolve unambiguously. Found two ambiguous paths: \`/{id}/ambiguous\` and \`/ambiguous/{id}\`.",
+          "ruleId": "no-ambiguous-paths",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1{entity}~1{id}~1last",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Paths should resolve unambiguously. Found two ambiguous paths: \`/good/{id}/{pet}\` and \`/{entity}/{id}/last\`.",
+          "ruleId": "no-ambiguous-paths",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});

package/src/rules/common/__tests__/no-enum-type-mismatch.test.ts

@@ -0,0 +1,209 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 typed enum', () => {
+  it('should not report on enum object if all items match type', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            /some:
+              get:
+                responses:
+                  '200':
+                    description: A paged array of pets
+                    content:
+                      application/json:
+                        schema:
+                          type: integer
+                          enum:
+                            - 1
+                            - 2
+                            - 3
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-enum-type-mismatch': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report on enum object if all items match type and enum is nullable', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            /some:
+              get:
+                responses:
+                  '200':
+                    description: A paged array of pets
+                    content:
+                      application/json:
+                        schema:
+                          type: string
+                          nullable: true
+                          enum:
+                            - A
+                            - B
+                            - C
+                            - null
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-enum-type-mismatch': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should report on enum object if not all items match type', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          paths:
+            /some:
+              get:
+                responses:
+                  '200':
+                    content:
+                      application/json:
+                        schema:
+                          type: integer
+                          enum:
+                            - 1
+                            - string
+                            - 3
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-enum-type-mismatch': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1some/get/responses/200/content/application~1json/schema/enum/1",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "All values of \`enum\` field must be of the same type as the \`type\` field: expected \\"integer\\" but received \\"string\\".",
+          "ruleId": "no-enum-type-mismatch",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on enum object, \'string\' value in enum does not have allowed types', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.1.0
+          paths:
+            /some:
+              get:
+                responses:
+                  '200':
+                    content:
+                      application/json:
+                        schema:
+                          type:
+                            - integer
+                            - array
+                          enum:
+                            - 1
+                            - string
+                            - 3
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-enum-type-mismatch': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1some/get/responses/200/content/application~1json/schema/enum/1",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Enum value \`string\` must be of one type. Allowed types: \`integer,array\`.",
+          "ruleId": "no-enum-type-mismatch",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not crash on null schema when there is spec rule', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            title: test
+            version: 1.2.3
+          paths:
+            /some:
+              get:
+                responses:
+                  '200':
+                    description: test
+                    content:
+                      application/json:
+                        schema: null
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'spec': 'error', 'no-enum-type-mismatch': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1some/get/responses/200/content/application~1json/schema",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Expected type \`Schema\` (object) but got \`null\`",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});

package/src/rules/common/__tests__/no-identical-paths.test.ts

@@ -0,0 +1,58 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('no-identical-paths', () => {
+  it('should report on identical paths', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/good/{id}':
+            get:
+              summary: List all pets
+          '/good/last':
+            get:
+              summary: List all pets
+          '/bad/{id}':
+            get:
+              summary: List all pets
+          '/good/{hash}':
+            get:
+              summary: List all pets
+          '/{id}/valid':
+            get:
+              summary: List all pets
+          '/valid/{id}':
+            get:
+              summary: List all pets
+        `,
+      'foobar.yaml',
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-identical-paths': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1good~1{hash}",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The path already exists which differs only by path parameter name(s): \`/good/{id}\` and \`/good/{hash}\`.",
+          "ruleId": "no-identical-paths",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});