@redocly/openapi-core 1.9.0 → 1.9.1

package/src/__tests__/ref-utils.test.ts

@@ -96,6 +96,28 @@ describe('ref-utils', () => {
     expect(result).toMatchInlineSnapshot(`[]`);
   });
 
+  it('should parse a ref correctly', () => {
+    expect(parseRef('./info.yaml#/description')).toEqual({
+      uri: './info.yaml',
+      pointer: ['description'],
+    });
+  });
+
+  it('should parse a ref which contain a hash in the middle', () => {
+    // Here `info#description.md` is a file name
+    expect(parseRef('./info#description.md')).toEqual({
+      uri: './info#description.md',
+      pointer: [],
+    });
+  });
+
+  it('should parse a ref which ends with a hash', () => {
+    expect(parseRef('./info.yaml#')).toEqual({
+      uri: './info.yaml',
+      pointer: [],
+    });
+  });
+
   describe('refBaseName', () => {
     it('returns base name for file reference', () => {
       expect(refBaseName('../testcase/Pet.yaml')).toStrictEqual('Pet');

package/src/config/__tests__/load.test.ts

@@ -137,6 +137,19 @@ describe('getConfig', () => {
           "severity": "warn",
           "suggest": [],
         },
+        {
+          "location": [
+            {
+              "pointer": "#/theme",
+              "reportOnKey": false,
+              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
+          "ruleId": "configuration no-unresolved-refs",
+          "severity": "warn",
+          "suggest": [],
+        },
         {
           "from": {
             "pointer": "#/rules",
@@ -154,19 +167,6 @@ describe('getConfig', () => {
           "severity": "warn",
           "suggest": [],
         },
-        {
-          "location": [
-            {
-              "pointer": "#/theme",
-              "reportOnKey": false,
-              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
-          "ruleId": "configuration no-unresolved-refs",
-          "severity": "warn",
-          "suggest": [],
-        },
       ]
     `);
   });

package/src/decorators/oas2/remove-unused-components.ts

@@ -1,8 +1,9 @@
-import type { Oas2Decorator } from '../../visitors';
 import { Location } from '../../ref-utils';
-import type { Oas2Components } from '../../typings/swagger';
 import { isEmptyObject } from '../../utils';
 
+import type { Oas2Decorator } from '../../visitors';
+import type { Oas2Components } from '../../typings/swagger';
+
 export const RemoveUnusedComponents: Oas2Decorator = () => {
   const components = new Map<
     string,

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

@@ -1,8 +1,9 @@
-import type { Oas3Decorator } from '../../visitors';
 import { Location } from '../../ref-utils';
-import type { Oas3Components } from '../../typings/openapi';
 import { isEmptyObject } from '../../utils';
 
+import type { Oas3Decorator } from '../../visitors';
+import type { Oas3Components } from '../../typings/openapi';
+
 export const RemoveUnusedComponents: Oas3Decorator = () => {
   const components = new Map<
     string,

package/src/lint.ts

@@ -112,6 +112,7 @@ export async function lintConfig(opts: {
   resolvedRefMap?: ResolvedRefMap;
   severity?: ProblemSeverity;
   externalRefResolver?: BaseResolver;
+  externalConfigTypes?: Record<string, NodeType>;
 }) {
   const { document, severity, externalRefResolver = new BaseResolver() } = opts;
 
@@ -126,7 +127,7 @@ export async function lintConfig(opts: {
     rules: { spec: 'error' },
   });
 
-  const types = normalizeTypes(ConfigTypes, config);
+  const types = normalizeTypes(opts.externalConfigTypes || ConfigTypes, config);
   const rules: (RuleInstanceConfig & {
     visitor: NestedVisitObject<unknown, Oas3Visitor | Oas3Visitor[]>;
   })[] = [

package/src/ref-utils.ts

@@ -43,9 +43,9 @@ export function escapePointer<T extends string | number>(fragment: T): T {
 }
 
 export function parseRef(ref: string): { uri: string | null; pointer: string[] } {
-  const [uri, pointer = ''] = ref.split('#');
+  const [uri, pointer = ''] = ref.split('#/');
   return {
-    uri: uri || null,
+    uri: (uri.endsWith('#') ? uri.slice(0, -1) : uri) || null,
     pointer: parsePointer(pointer),
   };
 }

package/src/resolve.ts

@@ -269,8 +269,20 @@ export async function resolveDocument(opts: {
         if (itemsType === undefined && type !== unknownType && type !== SpecExtension) {
           return;
         }
+        const isTypeAFunction = typeof itemsType === 'function';
         for (let i = 0; i < node.length; i++) {
-          walk(node[i], itemsType || unknownType, joinPointer(nodeAbsoluteRef, i));
+          const itemType = isTypeAFunction
+            ? itemsType(node[i], joinPointer(nodeAbsoluteRef, i))
+            : itemsType;
+          // we continue resolving unknown types, but stop early on known scalars
+          if (itemType === undefined && type !== unknownType && type !== SpecExtension) {
+            continue;
+          }
+          walk(
+            node[i],
+            isNamedType(itemType) ? itemType : unknownType,
+            joinPointer(nodeAbsoluteRef, i)
+          );
         }
         return;
       }

package/src/types/index.ts

@@ -21,31 +21,28 @@ export type NormalizedScalarSchema = {
 export type NodeType = {
   properties: Record<string, PropType | ResolveTypeFn>;
   additionalProperties?: PropType | ResolveTypeFn;
-  items?: string;
+  items?: PropType | ResolveTypeFn;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
   allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
-type PropType = string | NodeType | ScalarSchema | undefined | null;
-type ResolveTypeFn = (value: any, key: string) => string | PropType;
+export type PropType = string | NodeType | ScalarSchema | undefined | null;
+export type ResolveTypeFn = (value: any, key: string) => string | PropType;
 
 export type NormalizedNodeType = {
   name: string;
   properties: Record<string, NormalizedPropType | NormalizedResolveTypeFn>;
   additionalProperties?: NormalizedPropType | NormalizedResolveTypeFn;
-  items?: NormalizedNodeType;
+  items?: NormalizedPropType | NormalizedResolveTypeFn;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
   allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
 
-type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | undefined | null;
-type NormalizedResolveTypeFn = (
-  value: any,
-  key: string
-) => NormalizedNodeType | NormalizedScalarSchema | undefined | null;
+type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | null | undefined;
+type NormalizedResolveTypeFn = (value: any, key: string) => NormalizedPropType;
 
 export function listOf(typeName: string) {
   return {
@@ -142,8 +139,6 @@ export function normalizeTypes(
   }
 }
 
-export function isNamedType(
-  t: NormalizedNodeType | NormalizedScalarSchema | null | undefined
-): t is NormalizedNodeType {
+export function isNamedType(t: NormalizedPropType): t is NormalizedNodeType {
   return typeof t?.name === 'string';
 }

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,