@redocly/openapi-core 1.0.0-beta.102 → 1.0.0-beta.105

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,

package/src/utils.ts

@@ -1,11 +1,12 @@
 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 { env } from "./config";
+import { HttpResolveConfig } from './config';
+import { env } from './config';
 
 export { parseYaml, stringifyYaml } from './js-yaml';
 
@@ -26,9 +27,9 @@ export function popStack<T, P extends Stack<T>>(head: P) {
 
 export type BundleOutputFormat = 'json' | 'yml' | 'yaml';
 
-export async function loadYaml(filename: string) {
+export async function loadYaml<T>(filename: string): Promise<T> {
   const contents = await fs.promises.readFile(filename, 'utf-8');
-  return parseYaml(contents);
+  return parseYaml(contents) as T;
 }
 
 export function notUndefined<T>(x: T | undefined): x is T {
@@ -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)
@@ -155,14 +156,13 @@ export function isPathParameter(pathSegment: string) {
   return pathSegment.startsWith('{') && pathSegment.endsWith('}');
 }
 
-
 /**
  * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
  */
- export function slash(path: string): string {
-  const isExtendedLengthPath = /^\\\\\?\\/.test(path)
+export function slash(path: string): string {
+  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
   if (isExtendedLengthPath) {
-    return path
+    return path;
   }
 
   return path.replace(/\\/g, '/');
@@ -189,5 +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)
+  );
+}