@redocly/openapi-core 1.9.0 → 1.10.0

package/src/types/json-schema-adapter.ts

@@ -0,0 +1,217 @@
+// For internal usage only
+
+import Ajv from '@redocly/ajv/dist/2020';
+import { isPlainObject } from '../utils';
+
+import type { NodeType, PropType, ResolveTypeFn } from '.';
+import type { JSONSchema } from 'json-schema-to-ts';
+import { Oas3Schema } from '../typings/openapi';
+
+const ajv = new Ajv({
+  strictSchema: false,
+  allowUnionTypes: true,
+  useDefaults: true,
+  allErrors: true,
+  discriminator: true,
+  strictTypes: false,
+  verbose: true,
+});
+
+function findOneOf(schemaOneOf: JSONSchema[], oneOfs: (PropType | ResolveTypeFn)[]): ResolveTypeFn {
+  if (oneOfs.some((option) => typeof option === 'function')) {
+    throw new Error('Unexpected oneOf inside oneOf.');
+  }
+
+  return (value: unknown) => {
+    let index = schemaOneOf.findIndex((option) => ajv.validate(option, value));
+    if (index === -1) {
+      index = 0;
+    }
+    return oneOfs[index] as PropType;
+  };
+}
+
+function transformJSONSchemaToNodeType(
+  propertyName: string,
+  schema: JSONSchema,
+  ctx: Record<string, NodeType>
+): PropType | ResolveTypeFn {
+  if (!schema || typeof schema === 'boolean') {
+    throw new Error(`Unexpected schema in ${propertyName}.`);
+  }
+
+  if (schema instanceof Array) {
+    throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
+  }
+
+  if (schema.type === 'null') {
+    throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
+  }
+
+  if (schema.type instanceof Array) {
+    throw new Error(
+      `Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`
+    );
+  }
+
+  if (
+    schema.type === 'string' ||
+    schema.type === 'number' ||
+    schema.type === 'integer' ||
+    schema.type === 'boolean'
+  ) {
+    const { default: _, format: _format, ...rest } = schema;
+    return rest as PropType;
+  }
+
+  if (schema.type === 'object' && !schema.properties && !schema.oneOf) {
+    if (schema.additionalProperties === undefined || schema.additionalProperties === true) {
+      return { type: 'object' };
+    } else if (schema.additionalProperties === false) {
+      return { type: 'object', properties: {} };
+    }
+  }
+
+  if (schema.allOf) {
+    throw new Error(`Unexpected allOf in ${propertyName}.`);
+  }
+
+  if (schema.anyOf) {
+    throw new Error(`Unexpected anyOf in ${propertyName}.`);
+  }
+
+  if (
+    isPlainObject(schema.properties) ||
+    isPlainObject(schema.additionalProperties) ||
+    (isPlainObject(schema.items) &&
+      (isPlainObject(schema.items.properties) ||
+        isPlainObject(schema.items.additionalProperties) ||
+        schema.items.oneOf)) // exclude scalar array types
+  ) {
+    return extractNodeToContext(propertyName, schema, ctx);
+  }
+
+  if (schema.oneOf) {
+    if ((schema as Oas3Schema).discriminator) {
+      const discriminatedPropertyName = (schema as Oas3Schema).discriminator?.propertyName;
+      if (!discriminatedPropertyName) {
+        throw new Error(`Unexpected discriminator without a propertyName in ${propertyName}.`);
+      }
+      const oneOfs = schema.oneOf.map((option, i) => {
+        if (typeof option === 'boolean') {
+          throw new Error(
+            `Unexpected boolean schema in ${propertyName} at position ${i} in oneOf.`
+          );
+        }
+        const discriminatedProperty = option?.properties?.[discriminatedPropertyName];
+        if (!discriminatedProperty || typeof discriminatedProperty === 'boolean') {
+          throw new Error(
+            `Unexpected property '${discriminatedProperty}' schema in ${propertyName} at position ${i} in oneOf.`
+          );
+        }
+        const name = discriminatedProperty.const as string;
+        return transformJSONSchemaToNodeType(name, option, ctx);
+      });
+
+      return (value: unknown, key: string) => {
+        if (isPlainObject(value)) {
+          const discriminatedTypeName = value[discriminatedPropertyName];
+          if (typeof discriminatedTypeName === 'string' && ctx[discriminatedTypeName]) {
+            return discriminatedTypeName;
+          }
+        }
+        return findOneOf(schema.oneOf as JSONSchema[], oneOfs)(value, key);
+      };
+    } else {
+      const oneOfs = schema.oneOf.map((option, i) =>
+        transformJSONSchemaToNodeType(propertyName + '_' + i, option, ctx)
+      );
+      return findOneOf(schema.oneOf as JSONSchema[], oneOfs);
+    }
+  }
+
+  return schema as PropType;
+}
+
+function extractNodeToContext(
+  propertyName: string,
+  schema: JSONSchema,
+  ctx: Record<string, NodeType>
+): string {
+  if (!schema || typeof schema === 'boolean') {
+    throw new Error(`Unexpected schema in ${propertyName}.`);
+  }
+
+  if (schema instanceof Array) {
+    throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
+  }
+
+  if (schema.type === 'null') {
+    throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
+  }
+
+  if (schema.type instanceof Array) {
+    throw new Error(
+      `Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`
+    );
+  }
+
+  const properties: Record<string, PropType | ResolveTypeFn> = {};
+  for (const [name, property] of Object.entries(schema.properties || {})) {
+    properties[name] = transformJSONSchemaToNodeType(propertyName + '.' + name, property, ctx);
+  }
+
+  let additionalProperties;
+  if (isPlainObject(schema.additionalProperties)) {
+    additionalProperties = transformJSONSchemaToNodeType(
+      propertyName + '_additionalProperties',
+      schema.additionalProperties,
+      ctx
+    );
+  }
+  if (schema.additionalProperties === true) {
+    additionalProperties = {};
+  }
+
+  let items;
+  if (
+    isPlainObject(schema.items) &&
+    (isPlainObject(schema.items.properties) ||
+      isPlainObject(schema.items.additionalProperties) ||
+      schema.items.oneOf) // exclude scalar array types
+  ) {
+    items = transformJSONSchemaToNodeType(propertyName + '_items', schema.items, ctx);
+  }
+
+  let required = schema.required as NodeType['required'];
+  // Translate required in oneOfs into a ResolveTypeFn.
+  if (schema.oneOf && schema.oneOf.every((option) => !!(option as Oas3Schema).required)) {
+    required = (value): string[] => {
+      const requiredList: string[][] = schema.oneOf!.map((option) => [
+        ...(schema.required || []),
+        ...(option as Oas3Schema).required!,
+      ]);
+
+      let index = requiredList.findIndex((r) =>
+        r.every((requiredProp) => value[requiredProp] !== undefined)
+      );
+      if (index === -1) {
+        index = 0;
+      }
+
+      return requiredList[index];
+    };
+  }
+
+  ctx[propertyName] = { properties, additionalProperties, items, required };
+  return propertyName;
+}
+
+export function getNodeTypesFromJSONSchema(
+  schemaName: string,
+  entrySchema: JSONSchema
+): Record<string, NodeType> {
+  const ctx: Record<string, NodeType> = {};
+  transformJSONSchemaToNodeType(schemaName, entrySchema, ctx);
+  return ctx;
+}

package/src/types/oas2.ts

@@ -1,4 +1,7 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
+
+import type { NodeType } from '.';
+import type { Oas2NodeType } from './redocly-yaml';
 
 const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
 
@@ -437,7 +440,7 @@ const Example: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-export const Oas2Types: Record<string, NodeType> = {
+export const Oas2Types: Record<Oas2NodeType, NodeType> = {
   Root,
   Tag,
   TagList: listOf('Tag'),

package/src/types/oas3.ts

@@ -1,5 +1,9 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
 import { isMappingRef } from '../ref-utils';
+
+import type { NodeType } from '.';
+import type { Oas3NodeType } from './redocly-yaml';
+
 const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
 
 const Root: NodeType = {
@@ -531,7 +535,7 @@ const XUsePkce: NodeType = {
   },
 };
 
-export const Oas3Types: Record<string, NodeType> = {
+export const Oas3Types: Record<Oas3NodeType, NodeType> = {
   Root,
   Tag,
   TagList: listOf('Tag'),

package/src/types/oas3_1.ts

@@ -1,6 +1,9 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
 import { Oas3Types } from './oas3';
 
+import type { NodeType } from '.';
+import type { Oas3_1NodeType } from './redocly-yaml';
+
 const Root: NodeType = {
   properties: {
     openapi: null,
@@ -262,7 +265,7 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-export const Oas3_1Types: Record<string, NodeType> = {
+export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   ...Oas3Types,
   Info,
   Root,

package/src/types/portal-config-schema.ts

@@ -3,8 +3,10 @@ import {
   AuthProviderType,
   DEFAULT_TEAM_CLAIM_NAME,
 } from '../config';
+import { themeConfigSchema } from './theme-config';
 
-import type { NodeType } from '.';
+import type { FromSchema } from 'json-schema-to-ts';
+import type { ThemeConfig } from './theme-config';
 
 const oidcIssuerMetadataSchema = {
   type: 'object',
@@ -23,10 +25,11 @@ const oidcProviderConfigSchema = {
   properties: {
     type: { type: 'string', const: AuthProviderType.OIDC },
     title: { type: 'string' },
+    pkce: { type: 'boolean', default: false },
     configurationUrl: { type: 'string', minLength: 1 },
     configuration: oidcIssuerMetadataSchema,
     clientId: { type: 'string', minLength: 1 },
-    clientSecret: { type: 'string', minLength: 1 },
+    clientSecret: { type: 'string', minLength: 0 },
     teamsClaimName: { type: 'string' },
     teamsClaimMap: { type: 'object', additionalProperties: { type: 'string' } },
     defaultTeams: { type: 'array', items: { type: 'string' } },
@@ -36,7 +39,7 @@ const oidcProviderConfigSchema = {
     tokenRequestCustomParams: { type: 'object', additionalProperties: { type: 'string' } },
     audience: { type: 'array', items: { type: 'string' } },
   },
-  required: ['type', 'clientId', 'clientSecret'],
+  required: ['type', 'clientId'],
   oneOf: [{ required: ['configurationUrl'] }, { required: ['configuration'] }],
   additionalProperties: false,
 } as const;
@@ -87,11 +90,27 @@ const authProviderConfigSchema = {
   discriminator: { propertyName: 'type' },
 } as const;
 
-export const ssoConfigSchema = {
+const ssoOnPremConfigSchema = {
   type: 'object',
-  properties: {},
   additionalProperties: authProviderConfigSchema,
-} as NodeType;
+} as const;
+
+const ssoConfigSchema = {
+  oneOf: [
+    {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['REDOCLY', 'CORPORATE', 'GUEST'],
+      },
+      uniqueItems: true,
+    },
+    {
+      type: 'string',
+      enum: ['REDOCLY', 'CORPORATE', 'GUEST'],
+    },
+  ],
+} as const;
 
 const redirectConfigSchema = {
   type: 'object',
@@ -99,32 +118,34 @@ const redirectConfigSchema = {
     to: { type: 'string' },
     type: { type: 'number', default: 301 },
   },
-  required: ['to'],
-} as NodeType;
+  additionalProperties: false,
+} as const;
 
 const redirectsConfigSchema = {
   type: 'object',
-  properties: {},
-  additionalProperties: 'redirectConfigSchema',
+  additionalProperties: redirectConfigSchema,
   default: {},
-} as NodeType;
+} as const;
 
-export const apiConfigSchema = {
+const apiConfigSchema = {
   type: 'object',
   properties: {
     root: { type: 'string' },
+    output: { type: 'string', pattern: '(.ya?ml|.json)$' },
     rbac: { type: 'object', additionalProperties: true },
     theme: {
       type: 'object',
       properties: {
-        openapi: { type: 'object', additionalProperties: true },
+        openapi: themeConfigSchema.properties.openapi,
+        graphql: themeConfigSchema.properties.graphql,
       },
       additionalProperties: false,
     },
     title: { type: 'string' },
     metadata: { type: 'object', additionalProperties: true },
+    rules: { type: 'object', additionalProperties: true },
+    decorators: { type: 'object', additionalProperties: true },
   },
-  additionalProperties: true,
   required: ['root'],
 } as const;
 
@@ -140,7 +161,9 @@ const seoConfigSchema = {
     description: { type: 'string' },
     siteUrl: { type: 'string' },
     image: { type: 'string' },
-    keywords: { type: 'array', items: { type: 'string' } },
+    keywords: {
+      oneOf: [{ type: 'array', items: { type: 'string' } }, { type: 'string' }],
+    },
     lang: { type: 'string' },
     jsonLd: { type: 'object' },
     meta: {
@@ -156,21 +179,25 @@ const seoConfigSchema = {
       },
     },
   },
+  additionalProperties: false,
 } as const;
 
-const rbacScopeItemsSchema = {
-  type: 'object',
-  properties: {},
-  additionalProperties: { type: 'string' },
-} as NodeType;
+const rbacScopeItemsSchema = { type: 'object', additionalProperties: { type: 'string' } } as const;
 
 const rbacConfigSchema = {
   type: 'object',
   properties: {
-    defaults: 'rbacScopeItemsSchema',
+    cms: rbacScopeItemsSchema,
+    content: {
+      type: 'object',
+      properties: {
+        '**': rbacScopeItemsSchema,
+      },
+      additionalProperties: rbacScopeItemsSchema,
+    },
   },
   additionalProperties: rbacScopeItemsSchema,
-} as NodeType;
+} as const;
 
 const graviteeAdapterConfigSchema = {
   type: 'object',
@@ -246,13 +273,14 @@ const devOnboardingAdapterConfigSchema = {
 const devOnboardingConfigSchema = {
   type: 'object',
   required: ['adapters'],
+  additionalProperties: false,
   properties: {
     adapters: {
       type: 'array',
       items: devOnboardingAdapterConfigSchema,
     },
   },
-} as NodeType;
+} as const;
 
 const i18ConfigSchema = {
   type: 'object',
@@ -276,8 +304,9 @@ const i18ConfigSchema = {
       },
     },
   },
-  required: ['defaultLocale', 'locales'],
-} as NodeType;
+  additionalProperties: false,
+  required: ['defaultLocale'],
+} as const;
 
 const responseHeaderSchema = {
   type: 'object',
@@ -289,25 +318,13 @@ const responseHeaderSchema = {
   required: ['name', 'value'],
 } as const;
 
-export const PortalConfigNodeTypes: Record<string, NodeType> = {
-  seoConfigSchema,
-  rbacConfigSchema,
-  rbacScopeItemsSchema,
-  ssoConfigSchema,
-  devOnboardingConfigSchema,
-  i18ConfigSchema,
-  redirectsConfigSchema,
-  redirectConfigSchema,
-  // TODO: Extract other types that need to be linted in the config
-};
-
-export const redoclyConfigSchema = {
+const redoclyConfigSchema = {
   type: 'object',
   properties: {
     licenseKey: { type: 'string' },
-    redirects: 'redirectsConfigSchema',
-    seo: 'seoConfigSchema',
-    rbac: 'rbacConfigSchema',
+    redirects: redirectsConfigSchema,
+    seo: seoConfigSchema,
+    rbac: rbacConfigSchema,
     responseHeaders: {
       type: 'object',
       additionalProperties: {
@@ -329,38 +346,71 @@ export const redoclyConfigSchema = {
       type: 'object',
       additionalProperties: apiConfigSchema,
     },
-    sso: 'ssoConfigSchema',
-    developerOnboarding: 'devOnboardingConfigSchema',
-    i18n: 'i18ConfigSchema',
+    ssoOnPrem: ssoOnPremConfigSchema,
+    sso: ssoConfigSchema,
+    residency: { type: 'string' },
+    developerOnboarding: devOnboardingConfigSchema,
+    i18n: i18ConfigSchema,
     metadata: metadataConfigSchema,
-  },
-  default: {},
-} as NodeType;
-
-export const environmentSchema = {
-  oneOf: [
-    { ...redoclyConfigSchema, additionalProperties: false },
-    {
-      type: 'object',
-      properties: {
-        $ref: { type: 'string' },
+    ignore: {
+      type: 'array',
+      items: {
+        type: 'string',
       },
-      required: ['$ref'],
-      additionalProperties: false,
     },
-  ],
+    theme: themeConfigSchema,
+  },
+  default: { redirects: {} },
+  additionalProperties: true,
+} as const;
+
+const environmentSchema = {
+  ...redoclyConfigSchema,
+  additionalProperties: false,
 } as const;
 
 export const rootRedoclyConfigSchema = {
   ...redoclyConfigSchema,
   properties: {
+    plugins: {
+      type: 'array',
+      items: { type: 'string' },
+    },
     ...redoclyConfigSchema.properties,
     env: {
       type: 'object',
-      properties: {},
-      additionalProperties: environmentSchema,
+      additionalProperties: environmentSchema, // TODO: if we want full validation we need to override apis, theme and the root
     },
   },
   default: {},
-  required: ['redirects'],
+  additionalProperties: false,
 } as const;
+
+export type RedoclyConfig<T = ThemeConfig> = FromSchema<typeof rootRedoclyConfigSchema> & {
+  theme?: T;
+};
+export type RedirectConfig = FromSchema<typeof redirectConfigSchema>;
+export type RedirectsConfig = FromSchema<typeof redirectsConfigSchema>;
+
+export type AuthProviderConfig = FromSchema<typeof authProviderConfigSchema>;
+export type BasicAuthProviderConfig = FromSchema<typeof basicAuthProviderConfigSchema>;
+export type OidcProviderConfig = FromSchema<typeof oidcProviderConfigSchema>;
+export type Saml2ProviderConfig = FromSchema<typeof saml2ProviderConfigSchema>;
+export type SeoConfig = FromSchema<typeof seoConfigSchema>;
+export type RbacConfig = FromSchema<typeof rbacConfigSchema>;
+export type RbacScopeItems = FromSchema<typeof rbacScopeItemsSchema>;
+export type OidcIssuerMetadata = FromSchema<typeof oidcIssuerMetadataSchema>;
+
+export type DevOnboardingAdapterConfig = FromSchema<typeof devOnboardingAdapterConfigSchema>;
+export type GraviteeAdapterConfig = FromSchema<typeof graviteeAdapterConfigSchema>;
+export type ApigeeAdapterConfig = FromSchema<
+  typeof apigeeXAdapterConfigSchema | typeof apigeeEdgeAdapterConfigSchema
+>;
+export type ApigeeAdapterAuthOauth2 = FromSchema<typeof apigeeAdapterAuthOauth2Schema>;
+export type ApigeeAdapterAuthServiceAccount = FromSchema<
+  typeof apigeeAdapterAuthServiceAccountSchema
+>;
+export type SsoConfig = FromSchema<typeof ssoOnPremConfigSchema>;
+export type I18nConfig = FromSchema<typeof i18ConfigSchema>;
+
+export type ApiConfig = FromSchema<typeof apiConfigSchema>;