@redocly/openapi-core 1.9.0 → 1.9.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @redocly/openapi-core
 
+## 1.9.1
+
+### Patch Changes
+
+- Fixed a bug with resolving $refs to file names that contain the hash symbol.
+
 ## 1.9.0
 
 ### Minor Changes

package/lib/bundle.d.ts

@@ -47,4 +47,4 @@ export declare function bundleDocument(opts: {
     removeUnusedComponents?: boolean;
     keepUrlRefs?: boolean;
 }): Promise<BundleResult>;
-export declare function mapTypeToComponent(typeName: string, version: SpecMajorVersion): "responses" | "parameters" | "examples" | "headers" | "schemas" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | "definitions" | null;
+export declare function mapTypeToComponent(typeName: string, version: SpecMajorVersion): "parameters" | "examples" | "headers" | "schemas" | "responses" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | "definitions" | null;

package/lib/lint.d.ts

@@ -25,4 +25,5 @@ export declare function lintConfig(opts: {
     resolvedRefMap?: ResolvedRefMap;
     severity?: ProblemSeverity;
     externalRefResolver?: BaseResolver;
+    externalConfigTypes?: Record<string, NodeType>;
 }): Promise<import("./walk").NormalizedProblem[]>;

package/lib/lint.js

@@ -96,7 +96,7 @@ function lintConfig(opts) {
             plugins,
             rules: { spec: 'error' },
         });
-        const types = (0, types_1.normalizeTypes)(redocly_yaml_1.ConfigTypes, config);
+        const types = (0, types_1.normalizeTypes)(opts.externalConfigTypes || redocly_yaml_1.ConfigTypes, config);
         const rules = [
             {
                 severity: severity || 'error',

package/lib/oas-types.d.ts

@@ -24,4 +24,4 @@ export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
 export type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
 export declare function detectSpec(root: any): SpecVersion;
 export declare function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion;
-export declare function getTypes(spec: SpecVersion): Record<string, import("./types").NodeType>;
+export declare function getTypes(spec: SpecVersion): Record<string, import("./types").NodeType> | Record<"Root" | "Tag" | "ExternalDocs" | "SecurityRequirement" | "Info" | "Contact" | "License" | "Paths" | "PathItem" | "Parameter" | "Operation" | "Example" | "Header" | "Responses" | "Response" | "Schema" | "Xml" | "SchemaProperties" | "NamedSchemas" | "NamedResponses" | "NamedParameters" | "NamedSecuritySchemes" | "SecurityScheme" | "Examples" | "ExamplesMap" | "TagList" | "SecurityRequirementList" | "ParameterList" | "ParameterItems" | "TagGroup" | "TagGroups" | "EnumDescriptions" | "Logo" | "XCodeSample" | "XCodeSampleList" | "XServer" | "XServerList", import("./types").NodeType> | Record<"Root" | "Tag" | "ExternalDocs" | "Server" | "ServerVariable" | "SecurityRequirement" | "Info" | "Contact" | "License" | "Paths" | "PathItem" | "Callback" | "CallbacksMap" | "Parameter" | "Operation" | "RequestBody" | "MediaTypesMap" | "MediaType" | "Example" | "Encoding" | "Header" | "Responses" | "Response" | "Link" | "Schema" | "Xml" | "SchemaProperties" | "DiscriminatorMapping" | "Discriminator" | "Components" | "NamedSchemas" | "NamedResponses" | "NamedParameters" | "NamedExamples" | "NamedRequestBodies" | "NamedHeaders" | "NamedSecuritySchemes" | "NamedLinks" | "NamedCallbacks" | "ImplicitFlow" | "PasswordFlow" | "ClientCredentials" | "AuthorizationCode" | "OAuth2Flows" | "SecurityScheme" | "ServerVariablesMap" | "ExamplesMap" | "EncodingMap" | "HeadersMap" | "LinksMap" | "WebhooksMap" | "TagList" | "SecurityRequirementList" | "ParameterList" | "TagGroup" | "TagGroups" | "EnumDescriptions" | "Logo" | "XCodeSample" | "XCodeSampleList" | "ServerList" | "XUsePkce", import("./types").NodeType> | Record<"Root" | "Info" | "License" | "Operation" | "Schema" | "SchemaProperties" | "Components" | "SecurityScheme" | "NamedPathItems", import("./types").NodeType>;

package/lib/ref-utils.js

@@ -39,9 +39,9 @@ function escapePointer(fragment) {
 }
 exports.escapePointer = escapePointer;
 function parseRef(ref) {
-    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/lib/resolve.js

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

package/lib/types/index.d.ts

@@ -19,26 +19,26 @@ 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 declare function listOf(typeName: string): {
     name: string;
     properties: {};
@@ -53,5 +53,5 @@ export declare const SpecExtension: NormalizedNodeType;
 export declare function normalizeTypes(types: Record<string, NodeType>, options?: {
     doNotResolveExamples?: boolean;
 }): Record<string, NormalizedNodeType>;
-export declare function isNamedType(t: NormalizedNodeType | NormalizedScalarSchema | null | undefined): t is NormalizedNodeType;
+export declare function isNamedType(t: NormalizedPropType): t is NormalizedNodeType;
 export {};

package/lib/types/json-schema-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { NodeType } from '.';
+import type { JSONSchema } from 'json-schema-to-ts';
+export declare function getNodeTypesFromJSONSchema(schemaName: string, entrySchema: JSONSchema): Record<string, NodeType>;

package/lib/types/json-schema-adapter.js

@@ -0,0 +1,173 @@
+"use strict";
+// For internal usage only
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeTypesFromJSONSchema = void 0;
+const _2020_1 = require("@redocly/ajv/dist/2020");
+const utils_1 = require("../utils");
+const ajv = new _2020_1.default({
+    strictSchema: false,
+    allowUnionTypes: true,
+    useDefaults: true,
+    allErrors: true,
+    discriminator: true,
+    strictTypes: false,
+    verbose: true,
+});
+function findOneOf(schemaOneOf, oneOfs) {
+    if (oneOfs.some((option) => typeof option === 'function')) {
+        throw new Error('Unexpected oneOf inside oneOf.');
+    }
+    return (value) => {
+        let index = schemaOneOf.findIndex((option) => ajv.validate(option, value));
+        if (index === -1) {
+            index = 0;
+        }
+        return oneOfs[index];
+    };
+}
+function transformJSONSchemaToNodeType(propertyName, schema, ctx) {
+    var _a;
+    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 } = schema, rest = __rest(schema, ["default", "format"]);
+        return rest;
+    }
+    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 ((0, utils_1.isPlainObject)(schema.properties) ||
+        (0, utils_1.isPlainObject)(schema.additionalProperties) ||
+        ((0, utils_1.isPlainObject)(schema.items) &&
+            ((0, utils_1.isPlainObject)(schema.items.properties) ||
+                (0, utils_1.isPlainObject)(schema.items.additionalProperties) ||
+                schema.items.oneOf)) // exclude scalar array types
+    ) {
+        return extractNodeToContext(propertyName, schema, ctx);
+    }
+    if (schema.oneOf) {
+        if (schema.discriminator) {
+            const discriminatedPropertyName = (_a = schema.discriminator) === null || _a === void 0 ? void 0 : _a.propertyName;
+            if (!discriminatedPropertyName) {
+                throw new Error(`Unexpected discriminator without a propertyName in ${propertyName}.`);
+            }
+            const oneOfs = schema.oneOf.map((option, i) => {
+                var _a;
+                if (typeof option === 'boolean') {
+                    throw new Error(`Unexpected boolean schema in ${propertyName} at position ${i} in oneOf.`);
+                }
+                const discriminatedProperty = (_a = option === null || option === void 0 ? void 0 : option.properties) === null || _a === void 0 ? void 0 : _a[discriminatedPropertyName];
+                if (!discriminatedProperty || typeof discriminatedProperty === 'boolean') {
+                    throw new Error(`Unexpected property '${discriminatedProperty}' schema in ${propertyName} at position ${i} in oneOf.`);
+                }
+                const name = discriminatedProperty.const;
+                return transformJSONSchemaToNodeType(name, option, ctx);
+            });
+            return (value, key) => {
+                if ((0, utils_1.isPlainObject)(value)) {
+                    const discriminatedTypeName = value[discriminatedPropertyName];
+                    if (typeof discriminatedTypeName === 'string' && ctx[discriminatedTypeName]) {
+                        return discriminatedTypeName;
+                    }
+                }
+                return findOneOf(schema.oneOf, oneOfs)(value, key);
+            };
+        }
+        else {
+            const oneOfs = schema.oneOf.map((option, i) => transformJSONSchemaToNodeType(propertyName + '_' + i, option, ctx));
+            return findOneOf(schema.oneOf, oneOfs);
+        }
+    }
+    return schema;
+}
+function extractNodeToContext(propertyName, schema, ctx) {
+    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 = {};
+    for (const [name, property] of Object.entries(schema.properties || {})) {
+        properties[name] = transformJSONSchemaToNodeType(propertyName + '.' + name, property, ctx);
+    }
+    let additionalProperties;
+    if ((0, utils_1.isPlainObject)(schema.additionalProperties)) {
+        additionalProperties = transformJSONSchemaToNodeType(propertyName + '_additionalProperties', schema.additionalProperties, ctx);
+    }
+    if (schema.additionalProperties === true) {
+        additionalProperties = {};
+    }
+    let items;
+    if ((0, utils_1.isPlainObject)(schema.items) &&
+        ((0, utils_1.isPlainObject)(schema.items.properties) ||
+            (0, utils_1.isPlainObject)(schema.items.additionalProperties) ||
+            schema.items.oneOf) // exclude scalar array types
+    ) {
+        items = transformJSONSchemaToNodeType(propertyName + '_items', schema.items, ctx);
+    }
+    let required = schema.required;
+    // Translate required in oneOfs into a ResolveTypeFn.
+    if (schema.oneOf && schema.oneOf.every((option) => !!option.required)) {
+        required = (value) => {
+            const requiredList = schema.oneOf.map((option) => [
+                ...(schema.required || []),
+                ...option.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;
+}
+function getNodeTypesFromJSONSchema(schemaName, entrySchema) {
+    const ctx = {};
+    transformJSONSchemaToNodeType(schemaName, entrySchema, ctx);
+    return ctx;
+}
+exports.getNodeTypesFromJSONSchema = getNodeTypesFromJSONSchema;

package/lib/types/oas2.d.ts

@@ -1,2 +1,3 @@
-import { NodeType } from '.';
-export declare const Oas2Types: Record<string, NodeType>;
+import type { NodeType } from '.';
+import type { Oas2NodeType } from './redocly-yaml';
+export declare const Oas2Types: Record<Oas2NodeType, NodeType>;

package/lib/types/oas3.d.ts

@@ -1,2 +1,3 @@
-import { NodeType } from '.';
-export declare const Oas3Types: Record<string, NodeType>;
+import type { NodeType } from '.';
+import type { Oas3NodeType } from './redocly-yaml';
+export declare const Oas3Types: Record<Oas3NodeType, NodeType>;

package/lib/types/oas3_1.d.ts

@@ -1,2 +1,3 @@
-import { NodeType } from '.';
-export declare const Oas3_1Types: Record<string, NodeType>;
+import type { NodeType } from '.';
+import type { Oas3_1NodeType } from './redocly-yaml';
+export declare const Oas3_1Types: Record<Oas3_1NodeType, NodeType>;