@redocly/openapi-core 1.0.0-beta.103 → 1.0.0-beta.106

package/src/rules/oas3/__tests__/spec/spec.test.ts

@@ -1,13 +1,13 @@
 import { outdent } from 'outdent';
 import { lintDocument } from '../../../../lint';
 import { parseYamlToDocument, replaceSourceWithRef } from '../../../../../__tests__/utils';
-import { LintConfig, defaultPlugin, resolvePlugins, resolvePreset } from '../../../../config';
+import { StyleguideConfig, defaultPlugin, resolvePlugins, resolvePreset } from '../../../../config';
 
 import { BaseResolver } from '../../../../resolve';
 
 const plugins = resolvePlugins([defaultPlugin]);
 const pressets = resolvePreset('all', plugins);
-const allConfig = new LintConfig({ ...pressets, plugins });
+const allConfig = new StyleguideConfig({ ...pressets, plugins });
 describe('Oas3 Structural visitor basic', () => {
   it('should report wrong types', async () => {
     const document = parseYamlToDocument(
@@ -35,7 +35,7 @@ describe('Oas3 Structural visitor basic', () => {
             license: invalid
           paths: {}
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -110,7 +110,7 @@ describe('Oas3 Structural visitor basic', () => {
               "source": "foobar.yaml",
             },
           ],
-          "message": "Expected type \`string\` but got \`number\`.",
+          "message": "Expected type \`string\` but got \`integer\`.",
           "ruleId": "spec",
           "severity": "error",
           "suggest": Array [],
@@ -163,7 +163,7 @@ describe('Oas3 Structural visitor basic', () => {
               x-test: vendor
           paths: {}
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -232,7 +232,7 @@ describe('Oas3 Structural visitor basic', () => {
             contact:
               name: string
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({

package/src/rules/oas3/__tests__/spec/utils.ts

@@ -1,25 +1,25 @@
-import { LintConfig, RuleConfig, resolveLint } from '../../../../config';
+import { StyleguideConfig, RuleConfig, resolveStyleguideConfig } from '../../../../config';
 import { parseYamlToDocument } from '../../../../../__tests__/utils';
 import { lintDocument } from '../../../../lint';
 import { BaseResolver } from '../../../../resolve';
 
 export async function validateDoc(
   source: string,
-  rules: Record<string, RuleConfig> = { spec: 'error' },
+  rules: Record<string, RuleConfig> = { spec: 'error' }
 ) {
   const document = parseYamlToDocument(source, 'foobar.yaml');
 
   const results = await lintDocument({
     externalRefResolver: new BaseResolver(),
     document,
-    config: new LintConfig(
-      await resolveLint({
-        lintConfig: {
+    config: new StyleguideConfig(
+      await resolveStyleguideConfig({
+        styleguideConfig: {
           plugins: [],
           extends: [],
           rules,
         },
-      }),
+      })
     ),
   });
 

package/src/rules/oas3/index.ts

@@ -18,13 +18,13 @@ import { NoServerTrailingSlash } from './no-server-trailing-slash';
 import { InfoDescription } from '../common/info-description';
 import { TagDescription } from '../common/tag-description';
 import { InfoContact } from '../common/info-contact';
-import { InfoLicense } from '../common/info-license-url';
+import { InfoLicense } from '../common/info-license';
+import { InfoLicenseUrl } from '../common/info-license-url';
 import { OperationDescription } from '../common/operation-description';
 import { NoUnusedComponents } from './no-unused-components';
 import { PathNotIncludeQuery } from '../common/path-not-include-query';
 import { ParameterDescription } from '../common/parameter-description';
 import { OperationSingularTag } from '../common/operation-singular-tag';
-import { InfoLicenseUrl } from '../common/license-url';
 import { OperationSecurityDefined } from '../common/operation-security-defined';
 import { NoUnresolvedRefs } from '../no-unresolved-refs';
 import { BooleanParameterPrefixes } from './boolean-parameter-prefixes';
@@ -57,7 +57,7 @@ export const rules = {
   'info-license-url': InfoLicenseUrl,
   'operation-2xx-response': Operation2xxResponse,
   'operation-4xx-response': Operation4xxResponse,
-  'assertions': Assertions,
+  assertions: Assertions,
   'operation-operationId-unique': OperationIdUnique,
   'operation-parameters-unique': OperationParametersUnique,
   'path-parameters-defined': PathParamsDefined,

package/src/rules/oas3/no-empty-servers.ts

@@ -6,7 +6,7 @@ export const NoEmptyServers: Oas3Rule = () => {
       if (!root.hasOwnProperty('servers')) {
         report({
           message: 'Servers must be present.',
-          location: location.child(['openapi']).key()
+          location: location.child(['openapi']).key(),
         });
         return;
       }

package/src/rules/oas3/no-invalid-media-type-examples.ts

@@ -13,14 +13,22 @@ export const ValidContentExamples: Oas3Rule = (opts) => {
         const { location, resolve } = ctx;
         if (!mediaType.schema) return;
         if (mediaType.example) {
-         resolveAndValidateExample(mediaType.example, location.child('example'));
+          resolveAndValidateExample(mediaType.example, location.child('example'));
         } else if (mediaType.examples) {
           for (const exampleName of Object.keys(mediaType.examples)) {
-            resolveAndValidateExample(mediaType.examples[exampleName], location.child(['examples', exampleName, 'value']), true);
+            resolveAndValidateExample(
+              mediaType.examples[exampleName],
+              location.child(['examples', exampleName, 'value']),
+              true
+            );
           }
         }
 
-        function resolveAndValidateExample(example: Oas3Example | any, location: Location, isMultiple?: boolean) {
+        function resolveAndValidateExample(
+          example: Oas3Example | any,
+          location: Location,
+          isMultiple?: boolean
+        ) {
           if (isRef(example)) {
             const resolved = resolve<Oas3Example>(example);
             if (!resolved.location) return;
@@ -32,7 +40,7 @@ export const ValidContentExamples: Oas3Rule = (opts) => {
             mediaType.schema!,
             location,
             ctx,
-            disallowAdditionalProperties,
+            disallowAdditionalProperties
           );
         }
       },

package/src/rules/oas3/no-servers-empty-enum.ts

@@ -25,16 +25,17 @@ export const NoEmptyEnumServers: Oas3Rule = () => {
         invalidVariables.push(...enumErrors);
       }
 
-      for(const invalidVariable of invalidVariables) {
-        if(invalidVariable === enumError.empty) {
+      for (const invalidVariable of invalidVariables) {
+        if (invalidVariable === enumError.empty) {
           report({
             message: 'Server variable with `enum` must be a non-empty array.',
             location: location.child(['servers']).key(),
           });
         }
-        if(invalidVariable === enumError.invalidDefaultValue) {
+        if (invalidVariable === enumError.invalidDefaultValue) {
           report({
-            message: 'Server variable define `enum` and `default`. `enum` must include default value',
+            message:
+              'Server variable define `enum` and `default`. `enum` must include default value',
             location: location.child(['servers']).key(),
           });
         }
@@ -43,20 +44,18 @@ export const NoEmptyEnumServers: Oas3Rule = () => {
   };
 };
 
-function checkEnumVariables(server: Oas3Server): enumError[] | undefined{
-  if (server.variables && Object.keys(server.variables).length === 0)
-    return;
+function checkEnumVariables(server: Oas3Server): enumError[] | undefined {
+  if (server.variables && Object.keys(server.variables).length === 0) return;
 
   const errors: enumError[] = [];
-  for(var variable in server.variables) {
+  for (var variable in server.variables) {
     const serverVariable = server.variables[variable];
     if (!serverVariable.enum) continue;
 
     if (Array.isArray(serverVariable.enum) && serverVariable.enum?.length === 0)
       errors.push(enumError.empty);
 
-    if (!serverVariable.default)
-      continue;
+    if (!serverVariable.default) continue;
 
     const defaultValue = server.variables[variable].default;
     if (serverVariable.enum && !serverVariable.enum.includes(defaultValue))

package/src/rules/oas3/remove-unused-components.ts

@@ -1,12 +1,19 @@
 import { Oas3Rule } from '../../visitors';
 import { Location } from '../../ref-utils';
-import { Oas3Components } from '../../typings/openapi'
+import { Oas3Components } from '../../typings/openapi';
 import { isEmptyObject } from '../../utils';
 
 export const RemoveUnusedComponents: Oas3Rule = () => {
-  let components = new Map<string, { used: boolean; componentType?: keyof Oas3Components; name: string }>();
+  let components = new Map<
+    string,
+    { used: boolean; componentType?: keyof Oas3Components; name: string }
+  >();
 
-  function registerComponent(location: Location, componentType: keyof Oas3Components, name: string): void {
+  function registerComponent(
+    location: Location,
+    componentType: keyof Oas3Components,
+    name: string
+  ): void {
     components.set(location.absolutePointer, {
       used: components.get(location.absolutePointer)?.used || false,
       componentType,
@@ -18,7 +25,9 @@ export const RemoveUnusedComponents: Oas3Rule = () => {
     ref: {
       leave(ref, { type, resolve, key }) {
         if (
-          ['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(type.name)
+          ['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(
+            type.name
+          )
         ) {
           const resolvedRef = resolve(ref);
           if (!resolvedRef.location) return;
@@ -27,14 +36,14 @@ export const RemoveUnusedComponents: Oas3Rule = () => {
             name: key.toString(),
           });
         }
-      }
+      },
     },
     DefinitionRoot: {
       leave(root, ctx) {
         const data = ctx.getVisitorData() as { removedCount: number };
         data.removedCount = 0;
 
-        components.forEach(usageInfo => {
+        components.forEach((usageInfo) => {
           const { used, componentType, name } = usageInfo;
           if (!used && componentType) {
             let componentChild = root.components![componentType];
@@ -45,7 +54,9 @@ export const RemoveUnusedComponents: Oas3Rule = () => {
             }
           }
         });
-        if (isEmptyObject(root.components)) { delete root.components; }
+        if (isEmptyObject(root.components)) {
+          delete root.components;
+        }
       },
     },
     NamedSchemas: {

package/src/rules/other/stats.ts

@@ -4,10 +4,26 @@ import { StatsAccumulator } from '../../typings/common';
 
 export const Stats = (statsAccumulator: StatsAccumulator) => {
   return {
-    ExternalDocs: { leave() { statsAccumulator.externalDocs.total++; }},
-    ref: { enter(ref: OasRef) { statsAccumulator.refs.items!.add(ref['$ref']); }},
-    Tag: { leave(tag: Oas3Tag) { statsAccumulator.tags.items!.add(tag.name); }},
-    Link: { leave(link: any) { statsAccumulator.links.items!.add(link.operationId); }},
+    ExternalDocs: {
+      leave() {
+        statsAccumulator.externalDocs.total++;
+      },
+    },
+    ref: {
+      enter(ref: OasRef) {
+        statsAccumulator.refs.items!.add(ref['$ref']);
+      },
+    },
+    Tag: {
+      leave(tag: Oas3Tag) {
+        statsAccumulator.tags.items!.add(tag.name);
+      },
+    },
+    Link: {
+      leave(link: any) {
+        statsAccumulator.links.items!.add(link.operationId);
+      },
+    },
     DefinitionRoot: {
       leave() {
         statsAccumulator.parameters.total = statsAccumulator.parameters.items!.size;
@@ -19,26 +35,39 @@ export const Stats = (statsAccumulator: StatsAccumulator) => {
     WebhooksMap: {
       Operation: {
         leave(operation: any) {
-          operation.tags.forEach((tag: string) => { statsAccumulator.tags.items!.add(tag); })
-        }
-      }
+          operation.tags.forEach((tag: string) => {
+            statsAccumulator.tags.items!.add(tag);
+          });
+        },
+      },
     },
     PathMap: {
       PathItem: {
-        leave() { statsAccumulator.pathItems.total++; },
+        leave() {
+          statsAccumulator.pathItems.total++;
+        },
         Operation: {
           leave(operation: any) {
             statsAccumulator.operations.total++;
-            operation.tags && operation.tags.forEach((tag: string) => { statsAccumulator.tags.items!.add(tag); })
-          }
+            operation.tags &&
+              operation.tags.forEach((tag: string) => {
+                statsAccumulator.tags.items!.add(tag);
+              });
+          },
+        },
+        Parameter: {
+          leave(parameter: Oas2Parameter | Oas3Parameter) {
+            statsAccumulator.parameters.items!.add(parameter.name);
+          },
         },
-        Parameter: { leave(parameter: Oas2Parameter | Oas3Parameter) {
-          statsAccumulator.parameters.items!.add(parameter.name)
-        }},
       },
     },
     NamedSchemas: {
-      Schema: { leave() { statsAccumulator.schemas.total++; }}
-    }
-  }
-}
+      Schema: {
+        leave() {
+          statsAccumulator.schemas.total++;
+        },
+      },
+    },
+  };
+};

package/src/rules/utils.ts

@@ -9,6 +9,8 @@ export function oasTypeOf(value: unknown) {
     return 'array';
   } else if (value === null) {
     return 'null';
+  } else if (Number.isInteger(value)) {
+    return 'integer';
   } else {
     return typeof value;
   }
@@ -23,7 +25,7 @@ export function oasTypeOf(value: unknown) {
  */
 export function matchesJsonSchemaType(value: unknown, type: string, nullable: boolean): boolean {
   if (nullable && value === null) {
-    return value === null;
+    return true;
   }
 
   switch (type) {
@@ -89,7 +91,7 @@ export function validateExample(
   schema: Referenced<Oas3Schema>,
   dataLoc: Location,
   { resolve, location, report }: UserContext,
-  disallowAdditionalProperties: boolean,
+  disallowAdditionalProperties: boolean
 ) {
   try {
     const { valid, errors } = validateJsonSchema(
@@ -98,7 +100,7 @@ export function validateExample(
       location.child('schema'),
       dataLoc.pointer,
       resolve,
-      disallowAdditionalProperties,
+      disallowAdditionalProperties
     );
     if (!valid) {
       for (let error of errors) {

package/src/types/index.ts

@@ -24,7 +24,7 @@ export type NodeType = {
   items?: string;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
-  allowed?: ((value: any) => string[] | undefined);
+  allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
 type PropType = string | NodeType | ScalarSchema | undefined | null;
@@ -37,14 +37,14 @@ export type NormalizedNodeType = {
   items?: NormalizedNodeType;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
-  allowed?: ((value: any) => string[] | undefined);
+  allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
 
 type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | undefined | null;
 type NormalizedResolveTypeFn = (
   value: any,
-  key: string,
+  key: string
 ) => NormalizedNodeType | NormalizedScalarSchema | undefined | null;
 
 export function listOf(typeName: string) {
@@ -65,7 +65,7 @@ export function mapOf(typeName: string) {
 
 export function normalizeTypes(
   types: Record<string, NodeType>,
-  options: { doNotResolveExamples?: boolean } = {},
+  options: { doNotResolveExamples?: boolean } = {}
 ): Record<string, NormalizedNodeType> {
   const normalizedTypes: Record<string, NormalizedNodeType> = {};
 
@@ -132,7 +132,7 @@ export function normalizeTypes(
 }
 
 export function isNamedType(
-  t: NormalizedNodeType | NormalizedScalarSchema | null | undefined,
+  t: NormalizedNodeType | NormalizedScalarSchema | null | undefined
 ): t is NormalizedNodeType {
   return typeof t?.name === 'string';
 }

package/src/types/redocly-yaml.ts

@@ -50,6 +50,7 @@ const builtInRulesList = [
   'no-invalid-parameter-examples',
   'response-contains-header',
   'response-contains-property',
+  'scalar-property-missing-example',
 ];
 const nodeTypesList = [
   'DefinitionRoot',
@@ -109,7 +110,8 @@ const ConfigRoot: NodeType = {
       properties: {},
       additionalProperties: { properties: { type: 'string' } },
     }, // deprecated
-    lint: 'RootConfigLint',
+    styleguide: 'RootConfigStyleguide',
+    lint: 'RootConfigStyleguide', // deprecated
     'features.openapi': 'ConfigReferenceDocs',
     referenceDocs: 'ConfigReferenceDocs', // deprecated
     'features.mockServer': 'ConfigMockServer',
@@ -136,7 +138,7 @@ const ConfigApisProperties: NodeType = {
         type: 'string',
       },
     },
-    lint: 'ConfigLint',
+    styleguide: 'ConfigStyleguide',
     'features.openapi': 'ConfigReferenceDocs',
     'features.mockServer': 'ConfigMockServer',
   },
@@ -154,7 +156,7 @@ const ConfigHTTP: NodeType = {
   },
 };
 
-const ConfigLint: NodeType = {
+const ConfigStyleguide: NodeType = {
   properties: {
     extends: {
       type: 'array',
@@ -178,13 +180,13 @@ const ConfigLint: NodeType = {
   },
 };
 
-const RootConfigLint: NodeType = {
+const RootConfigStyleguide: NodeType = {
   properties: {
     plugins: {
       type: 'array',
       items: { type: 'string' },
     },
-    ...ConfigLint.properties,
+    ...ConfigStyleguide.properties,
   },
 };
 
@@ -876,8 +878,8 @@ export const ConfigTypes: Record<string, NodeType> = {
   ConfigRoot,
   ConfigApis,
   ConfigApisProperties,
-  RootConfigLint,
-  ConfigLint,
+  RootConfigStyleguide,
+  ConfigStyleguide,
   ConfigReferenceDocs,
   ConfigMockServer,
   ConfigHTTP,

package/src/typings/common.ts

@@ -5,5 +5,13 @@ export interface StatsRow {
   items?: Set<string>;
 }
 
-export type StatsName = 'operations' | 'refs' | 'tags' | 'externalDocs' | 'pathItems' | 'links' | 'schemas' | 'parameters';
+export type StatsName =
+  | 'operations'
+  | 'refs'
+  | 'tags'
+  | 'externalDocs'
+  | 'pathItems'
+  | 'links'
+  | 'schemas'
+  | 'parameters';
 export type StatsAccumulator = Record<StatsName, StatsRow>;

package/src/typings/openapi.ts

@@ -156,7 +156,7 @@ export interface Oas3Schema {
 export type Oas3_1Schema = Oas3Schema & {
   type?: string | string[];
   examples?: any[];
-}
+};
 
 export interface Oas3_1Definition extends Oas3Definition {
   webhooks?: Oas3_1Webhooks;

package/src/utils.ts

@@ -1,10 +1,11 @@
 import * as fs from 'fs';
+import { extname } from 'path';
 import * as minimatch from 'minimatch';
 import fetch from 'node-fetch';
 import * as pluralize from 'pluralize';
 import { parseYaml } from './js-yaml';
 import { UserContext } from './walk';
-import type { HttpResolveConfig } from './config';
+import { HttpResolveConfig } from './config';
 import { env } from './config';
 
 export { parseYaml, stringifyYaml } from './js-yaml';
@@ -77,16 +78,16 @@ function match(url: string, pattern: string) {
 
 export function pickObjectProps<T extends Record<string, unknown>>(
   object: T,
-  keys: Array<string>,
+  keys: Array<string>
 ): T {
   return Object.fromEntries(
-    keys.filter((key: string) => key in object).map((key: string) => [key, object[key]]),
+    keys.filter((key: string) => key in object).map((key: string) => [key, object[key]])
   ) as T;
 }
 
 export function omitObjectProps<T extends Record<string, unknown>>(
   object: T,
-  keys: Array<string>,
+  keys: Array<string>
 ): T {
   return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key))) as T;
 }
@@ -106,7 +107,7 @@ export function splitCamelCaseIntoWords(str: string) {
 export function validateMimeType(
   { type, value }: any,
   { report, location }: UserContext,
-  allowedValues: string[],
+  allowedValues: string[]
 ) {
   const ruleType = type === 'consumes' ? 'request' : 'response';
   if (!allowedValues)
@@ -126,7 +127,7 @@ export function validateMimeType(
 export function validateMimeTypeOAS3(
   { type, value }: any,
   { report, location }: UserContext,
-  allowedValues: string[],
+  allowedValues: string[]
 ) {
   const ruleType = type === 'consumes' ? 'request' : 'response';
   if (!allowedValues)
@@ -188,9 +189,18 @@ export function assignExisting<T>(target: Record<string, T>, obj: Record<string,
   }
 }
 
-export const getMatchingStatusCodeRange = (code: number | string): string =>
-  `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);
+export function getMatchingStatusCodeRange(code: number | string): string {
+  return `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);
+}
 
 export function isCustomRuleId(id: string) {
   return id.includes('/');
 }
+
+export function doesYamlFileExist(filePath: string): boolean {
+  return (
+    (extname(filePath) === '.yaml' || extname(filePath) === '.yml') &&
+    fs.hasOwnProperty('existsSync') &&
+    fs.existsSync(filePath)
+  );
+}

package/src/visitors.ts

@@ -53,7 +53,7 @@ export type VisitFunction<T> = (
   node: T,
   ctx: UserContext & { ignoreNextVisitorsOnNode: () => void },
   parents?: any,
-  context?: any,
+  context?: any
 ) => void;
 
 type VisitRefFunction = (node: OasRef, ctx: UserContext, resolved: ResolveResult<any>) => void;
@@ -264,7 +264,7 @@ export type RuleInstanceConfig = {
 
 export function normalizeVisitors<T extends BaseVisitor>(
   visitorsConfig: (RuleInstanceConfig & { visitor: NestedVisitObject<any, T> })[],
-  types: Record<keyof T, NormalizedNodeType>,
+  types: Record<keyof T, NormalizedNodeType>
 ): NormalizedOasVisitors<T> {
   const normalizedVisitors: NormalizedOasVisitors<T> = {} as any;
 
@@ -301,7 +301,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
     from: NormalizedNodeType,
     to: NormalizedNodeType,
     parentContext: VisitorLevelContext,
-    stack: NormalizedNodeType[] = [],
+    stack: NormalizedNodeType[] = []
   ) {
     if (stack.includes(from)) return;
 
@@ -363,7 +363,7 @@ export function normalizeVisitors<T extends BaseVisitor>(
     ruleConf: RuleInstanceConfig,
     visitor: NestedVisitObject<any, T>,
     parentContext: VisitorLevelContext | null,
-    depth = 0,
+    depth = 0
   ) {
     const visitorKeys = Object.keys(types) as Array<keyof T | 'any'>;