@redocly/openapi-core 1.9.0 → 1.10.0

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>;