@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/types/json-schema-adapter.js

@@ -0,0 +1,181 @@
+// For internal usage only
+import Ajv from '@redocly/ajv/dist/2020.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+const ajv = new Ajv({
+    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) {
+    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;
+    }
+    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.discriminator) {
+            const discriminatedPropertyName = schema.discriminator?.propertyName;
+            if (!discriminatedPropertyName) {
+                throw new Error(`Unexpected discriminator without a propertyName in ${propertyName}.`);
+            }
+            // Map discriminator values to their actual type names
+            const discriminatorMapping = {};
+            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 discriminatorValue = discriminatedProperty.const;
+                const actualTypeName = transformJSONSchemaToNodeType(discriminatorValue, option, ctx);
+                // Store mapping from discriminator value to actual type name
+                if (typeof actualTypeName === 'string') {
+                    discriminatorMapping[discriminatorValue] = actualTypeName;
+                }
+                return actualTypeName;
+            });
+            //TODO: investigate why this function doesn't invoke inside the current function scope
+            return (value, key) => {
+                if (isPlainObject(value)) {
+                    const discriminatedTypeName = value[discriminatedPropertyName];
+                    if (typeof discriminatedTypeName === 'string') {
+                        const actualTypeName = discriminatorMapping[discriminatedTypeName];
+                        if (actualTypeName && ctx[actualTypeName]) {
+                            return actualTypeName;
+                        }
+                    }
+                }
+                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.`);
+    }
+    // Use nodeTypeName from schema if provided, otherwise use propertyName
+    const nodeTypeName = schema.nodeTypeName ?? propertyName;
+    const properties = {};
+    for (const [name, property] of Object.entries(schema.properties || {})) {
+        properties[name] = transformJSONSchemaToNodeType(nodeTypeName + '.' + 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;
+    // 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[nodeTypeName] = {
+        properties,
+        additionalProperties,
+        items,
+        required,
+        description: schema.description,
+        documentationLink: schema.documentationLink,
+    };
+    return nodeTypeName;
+}
+export function getNodeTypesFromJSONSchema(schemaName, entrySchema) {
+    const ctx = {};
+    //TODO: fix this function to return discriminator resolvers in all NodeTypes that are returned in ctx. Currently it only only returns one discriminatorResolver for all types.
+    const discriminatorResolver = transformJSONSchemaToNodeType(schemaName, entrySchema, ctx);
+    return {
+        ctx,
+        discriminatorResolver: typeof discriminatorResolver === 'function' ? discriminatorResolver : undefined,
+    };
+}
+//# sourceMappingURL=json-schema-adapter.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/types/json-schema-draft7.shared.js

@@ -0,0 +1,101 @@
+import { isMappingRef } from '../ref-utils.js';
+import { listOf } from './index.js';
+export const Schema = {
+    properties: {
+        $id: { type: 'string' },
+        $schema: { type: 'string' },
+        definitions: 'NamedSchemas',
+        externalDocs: 'ExternalDocs',
+        discriminator: 'Discriminator',
+        title: { type: 'string' },
+        multipleOf: { type: 'number', minimum: 0 },
+        maximum: { type: 'number' },
+        minimum: { type: 'number' },
+        exclusiveMaximum: { type: 'number' },
+        exclusiveMinimum: { type: 'number' },
+        maxLength: { type: 'integer', minimum: 0 },
+        minLength: { type: 'integer', minimum: 0 },
+        pattern: { type: 'string' },
+        maxItems: { type: 'integer', minimum: 0 },
+        minItems: { type: 'integer', minimum: 0 },
+        uniqueItems: { type: 'boolean' },
+        maxProperties: { type: 'integer', minimum: 0 },
+        minProperties: { type: 'integer', minimum: 0 },
+        required: { type: 'array', items: { type: 'string' } },
+        enum: { type: 'array' },
+        type: (value) => {
+            return Array.isArray(value)
+                ? {
+                    type: 'array',
+                    items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+                }
+                : {
+                    enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+                };
+        },
+        allOf: listOf('Schema'),
+        anyOf: listOf('Schema'),
+        oneOf: listOf('Schema'),
+        not: 'Schema',
+        if: 'Schema',
+        then: 'Schema',
+        else: 'Schema',
+        contains: 'Schema',
+        patternProperties: { type: 'object' },
+        propertyNames: 'Schema',
+        properties: 'SchemaProperties',
+        items: (value) => {
+            return Array.isArray(value) ? listOf('Schema') : 'Schema';
+        },
+        additionalProperties: (value) => {
+            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+        },
+        description: { type: 'string' },
+        format: { type: 'string' },
+        contentEncoding: { type: 'string' },
+        contentMediaType: { type: 'string' },
+        default: null,
+        readOnly: { type: 'boolean' },
+        writeOnly: { type: 'boolean' },
+        examples: { type: 'array' },
+        example: { isExample: true },
+        deprecated: { type: 'boolean' },
+        const: null,
+        $comment: { type: 'string' },
+        additionalItems: (value) => {
+            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+        },
+        dependencies: 'Dependencies',
+    },
+};
+export const SchemaProperties = {
+    properties: {},
+    additionalProperties: (value) => {
+        return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+    },
+};
+export const Dependencies = {
+    properties: {},
+    additionalProperties: (value) => {
+        return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
+    },
+};
+export const DiscriminatorMapping = {
+    properties: {},
+    additionalProperties: (value) => {
+        if (isMappingRef(value)) {
+            return { type: 'string', directResolveAs: 'Schema' };
+        }
+        else {
+            return { type: 'string' };
+        }
+    },
+};
+export const Discriminator = {
+    properties: {
+        propertyName: { type: 'string' },
+        mapping: 'DiscriminatorMapping',
+    },
+    required: ['propertyName'],
+};
+//# sourceMappingURL=json-schema-draft7.shared.js.map