@redocly/openapi-core 1.0.0-beta.101 → 1.0.0-beta.104

package/src/rules/common/assertions/utils.ts

@@ -1,4 +1,4 @@
-import { isRef } from '../../../ref-utils';
+import { isRef, Location } from '../../../ref-utils';
 import { Problem, ProblemSeverity, UserContext } from '../../../walk';
 import { asserts } from './asserts';
 
@@ -23,7 +23,7 @@ export type AssertToApply = {
 export function buildVisitorObject(
   subject: string,
   context: Record<string, any>[],
-  subjectVisitor: any,
+  subjectVisitor: any
 ) {
   if (!context) {
     return { [subject]: subjectVisitor };
@@ -46,7 +46,7 @@ export function buildVisitorObject(
 
     if (matchParentKeys && excludeParentKeys) {
       throw new Error(
-        `Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`,
+        `Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`
       );
     }
 
@@ -75,9 +75,12 @@ export function buildVisitorObject(
 export function buildSubjectVisitor(
   properties: string | string[],
   asserts: AssertToApply[],
-  context?: Record<string, any>[],
+  context?: Record<string, any>[]
 ) {
-  return function (node: any, { report, location, key, type, resolve }: UserContext) {
+  return (
+    node: any,
+    { report, location, rawLocation, key, type, resolve, rawNode }: UserContext
+  ) => {
     // We need to check context's last node if it has the same type as subject node;
     // if yes - that means we didn't create context's last node visitor,
     // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
@@ -101,14 +104,28 @@ export function buildSubjectVisitor(
     }
 
     for (const assert of asserts) {
+      const currentLocation = assert.name === 'ref' ? rawLocation : location;
       if (properties) {
         for (const property of properties) {
           // we can have resolvable scalar so need to resolve value here.
           const value = isRef(node[property]) ? resolve(node[property])?.node : node[property];
-          runAssertion(value, assert, location.child(property), report);
+          runAssertion({
+            values: value,
+            rawValues: rawNode[property],
+            assert,
+            location: currentLocation.child(property),
+            report,
+          });
         }
       } else {
-        runAssertion(Object.keys(node), assert, location.key(), report);
+        const value = assert.name === 'ref' ? rawNode : Object.keys(node);
+        runAssertion({
+          values: Object.keys(node),
+          rawValues: value,
+          assert,
+          location: currentLocation,
+          report,
+        });
       }
     }
   };
@@ -148,20 +165,28 @@ export function isOrdered(value: any[], options: OrderOptions | OrderDirection):
   return true;
 }
 
-function runAssertion(
-  values: string | string[],
-  assert: AssertToApply,
-  location: any,
-  report: (problem: Problem) => void,
-) {
-  const lintResult = asserts[assert.name](values, assert.conditions);
-  if (!lintResult) {
+type RunAssertionParams = {
+  values: string | string[];
+  rawValues: any;
+  assert: AssertToApply;
+  location: Location;
+  report: (problem: Problem) => void;
+};
+
+function runAssertion({ values, rawValues, assert, location, report }: RunAssertionParams) {
+  const lintResult = asserts[assert.name](values, assert.conditions, location, rawValues);
+  if (!lintResult.isValid) {
     report({
       message: assert.message || `The ${assert.assertId} doesn't meet required conditions`,
-      location,
+      location: lintResult.location || location,
       forceSeverity: assert.severity,
       suggest: assert.suggest,
       ruleId: assert.assertId,
     });
   }
 }
+
+export function regexFromString(input: string): RegExp | null {
+  const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
+  return matches && new RegExp(matches[1] || matches[3], matches[2]);
+}

package/src/types/redocly-yaml.ts

@@ -1,13 +1,125 @@
 import { NodeType, listOf } from '.';
-import { omitObjectProps, pickObjectProps } from '../utils';
+import { omitObjectProps, pickObjectProps, isCustomRuleId } from '../utils';
+const builtInRulesList = [
+  'spec',
+  'info-description',
+  'info-contact',
+  'info-license',
+  'info-license-url',
+  'operation-2xx-response',
+  'operation-4xx-response',
+  'assertions',
+  'operation-operationId-unique',
+  'operation-parameters-unique',
+  'path-parameters-defined',
+  'operation-tag-defined',
+  'no-example-value-and-externalValue',
+  'no-enum-type-mismatch',
+  'no-path-trailing-slash',
+  'no-empty-servers',
+  'path-declaration-must-exist',
+  'operation-operationId-url-safe',
+  'operation-operationId',
+  'operation-summary',
+  'tags-alphabetical',
+  'no-server-example.com',
+  'no-server-trailing-slash',
+  'tag-description',
+  'operation-description',
+  'no-unused-components',
+  'path-not-include-query',
+  'path-params-defined',
+  'parameter-description',
+  'operation-singular-tag',
+  'operation-security-defined',
+  'no-unresolved-refs',
+  'paths-kebab-case',
+  'boolean-parameter-prefixes',
+  'path-http-verbs-order',
+  'no-invalid-media-type-examples',
+  'no-identical-paths',
+  'no-ambiguous-paths',
+  'no-undefined-server-variable',
+  'no-servers-empty-enum',
+  'no-http-verbs-in-paths',
+  'path-excludes-patterns',
+  'request-mime-type',
+  'response-mime-type',
+  'path-segment-plural',
+  'no-invalid-schema-examples',
+  'no-invalid-parameter-examples',
+  'response-contains-header',
+  'response-contains-property',
+  'scalar-property-missing-example',
+];
+const nodeTypesList = [
+  'DefinitionRoot',
+  'Tag',
+  'ExternalDocs',
+  'Server',
+  'ServerVariable',
+  'SecurityRequirement',
+  'Info',
+  'Contact',
+  'License',
+  'PathMap',
+  'PathItem',
+  'Parameter',
+  'Operation',
+  'Callback',
+  'RequestBody',
+  'MediaTypeMap',
+  'MediaType',
+  'Example',
+  'Encoding',
+  'Header',
+  'ResponsesMap',
+  'Response',
+  'Link',
+  'Schema',
+  'Xml',
+  'SchemaProperties',
+  'DiscriminatorMapping',
+  'Discriminator',
+  'Components',
+  'NamedSchemas',
+  'NamedResponses',
+  'NamedParameters',
+  'NamedExamples',
+  'NamedRequestBodies',
+  'NamedHeaders',
+  'NamedSecuritySchemes',
+  'NamedLinks',
+  'NamedCallbacks',
+  'ImplicitFlow',
+  'PasswordFlow',
+  'ClientCredentials',
+  'AuthorizationCode',
+  'SecuritySchemeFlows',
+  'SecurityScheme',
+  'XCodeSample',
+  'WebhooksMap',
+];
 
 const ConfigRoot: NodeType = {
   properties: {
     organization: { type: 'string' },
     apis: 'ConfigApis',
+    apiDefinitions: {
+      type: 'object',
+      properties: {},
+      additionalProperties: { properties: { type: 'string' } },
+    }, // deprecated
     lint: 'RootConfigLint',
     'features.openapi': 'ConfigReferenceDocs',
+    referenceDocs: 'ConfigReferenceDocs', // deprecated
     'features.mockServer': 'ConfigMockServer',
+    region: { enum: ['us', 'eu'] },
+    resolve: {
+      properties: {
+        http: 'ConfigHTTP',
+      },
+    },
   },
 };
 
@@ -19,9 +131,17 @@ const ConfigApis: NodeType = {
 const ConfigApisProperties: NodeType = {
   properties: {
     root: { type: 'string' },
+    labels: {
+      type: 'array',
+      items: {
+        type: 'string',
+      },
+    },
     lint: 'ConfigLint',
     'features.openapi': 'ConfigReferenceDocs',
+    'features.mockServer': 'ConfigMockServer',
   },
+  required: ['root'],
 };
 
 const ConfigHTTP: NodeType = {
@@ -44,10 +164,10 @@ const ConfigLint: NodeType = {
       },
     },
     doNotResolveExamples: { type: 'boolean' },
-    rules: { type: 'object' },
-    oas2Rules: { type: 'object' },
-    oas3_0Rules: { type: 'object' },
-    oas3_1Rules: { type: 'object' },
+    rules: 'Rules',
+    oas2Rules: 'Rules',
+    oas3_0Rules: 'Rules',
+    oas3_1Rules: 'Rules',
     preprocessors: { type: 'object' },
     oas2Preprocessors: { type: 'object' },
     oas3_0Preprocessors: { type: 'object' },
@@ -56,11 +176,6 @@ const ConfigLint: NodeType = {
     oas2Decorators: { type: 'object' },
     oas3_0Decorators: { type: 'object' },
     oas3_1Decorators: { type: 'object' },
-    resolve: {
-      properties: {
-        http: 'ConfigHTTP',
-      },
-    },
   },
 };
 
@@ -74,11 +189,111 @@ const RootConfigLint: NodeType = {
   },
 };
 
+const Rules: NodeType = {
+  properties: {},
+  additionalProperties: (value: unknown, key: string) => {
+    if (key.startsWith('assert/')) {
+      return 'Assert';
+    } else if (builtInRulesList.includes(key) || isCustomRuleId(key)) {
+      if (typeof value === 'string') {
+        return { enum: ['error', 'warn', 'off'] };
+      } else {
+        return 'ObjectRule';
+      }
+    }
+    // Otherwise is considered as invalid
+    return;
+  },
+};
+
+const ObjectRule: NodeType = {
+  properties: {
+    severity: { enum: ['error', 'warn', 'off'] },
+  },
+  additionalProperties: {},
+  required: ['severity'],
+};
+
+const Assert: NodeType = {
+  properties: {
+    subject: (value: unknown) => {
+      if (Array.isArray(value)) {
+        return { type: 'array', items: { enum: nodeTypesList } };
+      } else {
+        return { enum: nodeTypesList };
+      }
+    },
+    property: (value: unknown) => {
+      if (Array.isArray(value)) {
+        return { type: 'array', items: { type: 'string' } };
+      } else if (value === null) {
+        return null;
+      } else {
+        return { type: 'string' };
+      }
+    },
+    context: listOf('Context'),
+    message: { type: 'string' },
+    suggest: { type: 'array', items: { type: 'string' } },
+    severity: { enum: ['error', 'warn', 'off'] },
+    enum: { type: 'array', items: { type: 'string' } },
+    pattern: { type: 'string' },
+    casing: {
+      enum: [
+        'camelCase',
+        'kebab-case',
+        'snake_case',
+        'PascalCase',
+        'MACRO_CASE',
+        'COBOL-CASE',
+        'flatcase',
+      ],
+    },
+    mutuallyExclusive: { type: 'array', items: { type: 'string' } },
+    mutuallyRequired: { type: 'array', items: { type: 'string' } },
+    required: { type: 'array', items: { type: 'string' } },
+    requireAny: { type: 'array', items: { type: 'string' } },
+    disallowed: { type: 'array', items: { type: 'string' } },
+    defined: { type: 'boolean' },
+    undefined: { type: 'boolean' },
+    nonEmpty: { type: 'boolean' },
+    minLength: { type: 'integer' },
+    maxLength: { type: 'integer' },
+    ref: (value: string | boolean) =>
+      typeof value === 'string' ? { type: 'string' } : { type: 'boolean' },
+  },
+  required: ['subject'],
+};
+
+const Context: NodeType = {
+  properties: {
+    type: { enum: nodeTypesList },
+    matchParentKeys: { type: 'array', items: { type: 'string' } },
+    excludeParentKeys: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['type'],
+};
+
 const ConfigLanguage: NodeType = {
   properties: {
     label: { type: 'string' },
-    lang: { type: 'string' },
+    lang: {
+      enum: [
+        'curl',
+        'C#',
+        'Go',
+        'Java',
+        'Java8+Apache',
+        'JavaScript',
+        'Node.js',
+        'PHP',
+        'Python',
+        'R',
+        'Ruby',
+      ],
+    },
   },
+  required: ['lang'],
 };
 
 const ConfigLabels: NodeType = {
@@ -102,11 +317,18 @@ const ConfigLabels: NodeType = {
 
 const ConfigSidebarLinks: NodeType = {
   properties: {
-    placement: { type: 'string' },
+    beforeInfo: listOf('CommonConfigSidebarLinks'),
+    end: listOf('CommonConfigSidebarLinks'),
+  },
+};
+
+const CommonConfigSidebarLinks: NodeType = {
+  properties: {
     label: { type: 'string' },
     link: { type: 'string' },
     target: { type: 'string' },
   },
+  required: ['label', 'link'],
 };
 
 const CommonThemeColors: NodeType = {
@@ -147,7 +369,7 @@ const HttpColors: NodeType = {
 
 const ResponseColors: NodeType = {
   properties: {
-    errors: 'CommonColorProps',
+    error: 'CommonColorProps',
     info: 'CommonColorProps',
     redirect: 'CommonColorProps',
     success: 'CommonColorProps',
@@ -242,12 +464,15 @@ const HttpBadgesConfig: NodeType = {
 const LabelControls: NodeType = {
   properties: {
     top: { type: 'string' },
+    width: { type: 'string' },
+    height: { type: 'string' },
   },
 };
 
 const Panels: NodeType = {
   properties: {
     borderRadius: { type: 'string' },
+    backgroundColor: { type: 'string' },
   },
 };
 
@@ -285,6 +510,7 @@ const StackedConfig: NodeType = {
 const ThreePanelConfig: NodeType = {
   properties: {
     maxWidth: 'Breakpoints',
+    middlePanelMaxWidth: 'Breakpoints',
   },
 };
 
@@ -378,7 +604,18 @@ const CodeConfig: NodeType = {
     ...FontConfig.properties,
     backgroundColor: { type: 'string' },
     color: { type: 'string' },
-    wordBreak: { type: 'string' },
+    wordBreak: {
+      enum: [
+        'break-all',
+        'break-word',
+        'keep-all',
+        'normal',
+        'revert',
+        'unset',
+        'inherit',
+        'initial',
+      ],
+    },
     wrap: { type: 'boolean' },
   },
 };
@@ -413,7 +650,7 @@ const Typography: NodeType = {
     links: 'LinksConfig',
     optimizeSpeed: { type: 'boolean' },
     rightPanelHeading: 'Heading',
-    smoothing: { type: 'string' },
+    smoothing: { enum: ['auto', 'none', 'antialiased', 'subpixel-antialiased', 'grayscale'] },
   },
 };
 
@@ -440,6 +677,13 @@ const Logo: NodeType = {
   },
 };
 
+const Fab: NodeType = {
+  properties: {
+    backgroundColor: { type: 'string' },
+    color: { type: 'string' },
+  },
+};
+
 const ButtonOverrides: NodeType = {
   properties: {
     custom: { type: 'string' },
@@ -484,6 +728,7 @@ const ConfigTheme: NodeType = {
     components: 'Components',
     layout: 'Layout',
     logo: 'Logo',
+    fab: 'Fab',
     overrides: 'Overrides',
     rightPanel: 'RightPanel',
     schema: 'Schema',
@@ -491,8 +736,8 @@ const ConfigTheme: NodeType = {
     sidebar: 'Sidebar',
     spacing: 'ThemeSpacing',
     typography: 'Typography',
-    links: { properties: { color: { type: 'string' } } },
-    codeSample: { properties: { backgroundColor: { type: 'string' } } },
+    links: { properties: { color: { type: 'string' } } }, // deprecated
+    codeSample: { properties: { backgroundColor: { type: 'string' } } }, // deprecated
   },
 };
 
@@ -501,6 +746,7 @@ const GenerateCodeSamples: NodeType = {
     skipOptionalParameters: { type: 'boolean' },
     languages: listOf('ConfigLanguage'),
   },
+  required: ['languages'],
 };
 
 const ConfigReferenceDocs: NodeType = {
@@ -515,8 +761,8 @@ const ConfigReferenceDocs: NodeType = {
     downloadDefinitionUrl: { type: 'string' },
     expandDefaultServerVariables: { type: 'boolean' },
     enumSkipQuotes: { type: 'boolean' },
-    expandDefaultRequest: { type: 'boolean'},
-    expandDefaultResponse: { type: 'boolean'},
+    expandDefaultRequest: { type: 'boolean' },
+    expandDefaultResponse: { type: 'boolean' },
     expandResponses: { type: 'string' },
     expandSingleSchemaField: { type: 'boolean' },
     generateCodeSamples: 'GenerateCodeSamples',
@@ -527,43 +773,77 @@ const ConfigReferenceDocs: NodeType = {
     hideLoading: { type: 'boolean' },
     hideLogo: { type: 'boolean' },
     hideRequestPayloadSample: { type: 'boolean' },
+    hideRightPanel: { type: 'boolean' },
     hideSchemaPattern: { type: 'boolean' },
     hideSchemaTitles: { type: 'boolean' },
     hideSingleRequestSampleTab: { type: 'boolean' },
+    hideSecuritySection: { type: 'boolean' },
     hideTryItPanel: { type: 'boolean' },
     hideFab: { type: 'boolean' },
-    hideOneOfDescription: { type: 'boolean'},
+    hideOneOfDescription: { type: 'boolean' },
     htmlTemplate: { type: 'string' },
-    jsonSampleExpandLevel: { type: 'string' },
+    jsonSampleExpandLevel: (value: unknown) => {
+      if (typeof value === 'number') {
+        return { type: 'number', minimum: 1 };
+      } else {
+        return { type: 'string' };
+      }
+    },
     labels: 'ConfigLabels',
-    layout: { type: 'string' },
+    layout: { enum: ['stacked', 'three-panel'] },
     maxDisplayedEnumValues: { type: 'number' },
     menuToggle: { type: 'boolean' },
     nativeScrollbars: { type: 'boolean' },
-    noAutoAuth: { type: 'boolean' },
+    noAutoAuth: { type: 'boolean' }, // deprecated
     oAuth2RedirectURI: { type: 'string' },
     onDeepLinkClick: { type: 'object' },
     onlyRequiredInSamples: { type: 'boolean' },
-    pagination: { type: 'string' },
+    pagination: { enum: ['none', 'section', 'item'] },
     pathInMiddlePanel: { type: 'boolean' },
-    payloadSampleIdx: { type: 'number' },
+    payloadSampleIdx: { type: 'number', minimum: 0 },
     requestInterceptor: { type: 'object' },
     requiredPropsFirst: { type: 'boolean' },
     routingBasePath: { type: 'string' },
+    routingStrategy: { type: 'string' }, // deprecated
     samplesTabsMaxCount: { type: 'number' },
-    schemaExpansionLevel: { type: 'string' },
+    schemaExpansionLevel: (value: unknown) => {
+      if (typeof value === 'number') {
+        return { type: 'number', minimum: 0 };
+      } else {
+        return { type: 'string' };
+      }
+    },
     schemaDefinitionsTagName: { type: 'string' },
-    minCharacterLengthToInitSearch: { type: 'number' },
-    maxResponseHeadersToShowInTryIt: {type: 'number'},
-    scrollYOffset: { type: 'string' },
+    minCharacterLengthToInitSearch: { type: 'number', minimum: 1 },
+    maxResponseHeadersToShowInTryIt: { type: 'number', minimum: 0 },
+    scrollYOffset: (value: unknown) => {
+      if (typeof value === 'number') {
+        return { type: 'number' };
+      } else {
+        return { type: 'string' };
+      }
+    },
     searchAutoExpand: { type: 'boolean' },
-    searchFieldLevelBoost: { type: 'number' },
-    searchMode: { type: 'string' },
+    searchFieldLevelBoost: { type: 'number', minimum: 0 },
+    searchMaxDepth: { type: 'number', minimum: 1 },
+    searchMode: { enum: ['default', 'path-only'] },
     searchOperationTitleBoost: { type: 'number' },
     searchTagTitleBoost: { type: 'number' },
+    sendXUserAgentInTryIt: { type: 'boolean' },
     showChangeLayoutButton: { type: 'boolean' },
-    showConsole: { type: 'boolean' },
-    showExtensions: { type: 'boolean' },
+    showConsole: { type: 'boolean' }, // deprecated
+    showExtensions: (value: unknown) => {
+      if (typeof value === 'boolean') {
+        return { type: 'boolean' };
+      } else {
+        return {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        };
+      }
+    },
     showNextButton: { type: 'boolean' },
     showRightPanelToggle: { type: 'boolean' },
     showSecuritySchemeType: { type: 'boolean' },
@@ -571,12 +851,14 @@ const ConfigReferenceDocs: NodeType = {
     showObjectSchemaExamples: { type: 'boolean' },
     disableTryItRequestUrlEncoding: { type: 'boolean' },
     sidebarLinks: 'ConfigSidebarLinks',
-    sideNavStyle: { type: 'string' },
+    sideNavStyle: { enum: ['summary-only', 'path-first', 'id-only'] },
     simpleOneOfTypeLabel: { type: 'boolean' },
     sortEnumValuesAlphabetically: { type: 'boolean' },
     sortOperationsAlphabetically: { type: 'boolean' },
     sortPropsAlphabetically: { type: 'boolean' },
     sortTagsAlphabetically: { type: 'boolean' },
+    suppressWarnings: { type: 'boolean' }, // deprecated
+    unstable_externalDescription: { type: 'boolean' }, // deprecated
     unstable_ignoreMimeParameters: { type: 'boolean' },
     untrustedDefinition: { type: 'boolean' },
   },
@@ -591,6 +873,7 @@ const ConfigMockServer: NodeType = {
 };
 
 export const ConfigTypes: Record<string, NodeType> = {
+  Assert,
   ConfigRoot,
   ConfigApis,
   ConfigApisProperties,
@@ -602,7 +885,9 @@ export const ConfigTypes: Record<string, NodeType> = {
   ConfigLanguage,
   ConfigLabels,
   ConfigSidebarLinks,
+  CommonConfigSidebarLinks,
   ConfigTheme,
+  Context,
   ThemeColors,
   CommonThemeColors,
   BorderThemeColors,
@@ -633,9 +918,12 @@ export const ConfigTypes: Record<string, NodeType> = {
   TokenProps,
   CodeBlock,
   Logo,
+  Fab,
   ButtonOverrides,
   Overrides,
+  ObjectRule,
   RightPanel,
+  Rules,
   Shape,
   ThemeSpacing,
   GenerateCodeSamples,