@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/types/asyncapi3.d.ts

@@ -0,0 +1,2 @@
+import type { NodeType } from '.';
+export declare const AsyncApi3Types: Record<string, NodeType>;

package/lib/types/asyncapi3.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncApi3Types = void 0;
+const _1 = require(".");
+const asyncapi2_1 = require("./asyncapi2");
+const Root = {
+    properties: {
+        asyncapi: { type: 'string', enum: ['3.0.0'] },
+        info: 'Info',
+        id: { type: 'string' },
+        servers: 'ServerMap',
+        channels: 'NamedChannels',
+        components: 'Components',
+        operations: 'NamedOperations',
+        defaultContentType: { type: 'string' },
+    },
+    required: ['asyncapi', 'info'],
+};
+const Channel = {
+    properties: {
+        address: { type: 'string' },
+        messages: 'NamedMessages',
+        title: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        servers: 'ServerList',
+        parameters: 'ParametersMap',
+        bindings: 'ChannelBindings',
+        tags: 'TagList',
+        externalDocs: 'ExternalDocs',
+    },
+};
+const Server = {
+    properties: {
+        host: { type: 'string' },
+        pathname: { type: 'string' },
+        protocol: { type: 'string' },
+        protocolVersion: { type: 'string' },
+        description: { type: 'string' },
+        variables: 'ServerVariablesMap',
+        security: 'SecuritySchemeList',
+        bindings: 'ServerBindings',
+        externalDocs: 'ExternalDocs',
+        tags: 'TagList',
+    },
+    required: ['host', 'protocol'],
+};
+const Info = {
+    properties: {
+        title: { type: 'string' },
+        version: { type: 'string' },
+        description: { type: 'string' },
+        termsOfService: { type: 'string' },
+        contact: 'Contact',
+        license: 'License',
+        tags: 'TagList',
+        externalDocs: 'ExternalDocs',
+    },
+    required: ['title', 'version'],
+};
+const Parameter = {
+    properties: {
+        description: { type: 'string' },
+        enum: { type: 'array', items: { type: 'string' } },
+        default: { type: 'string' },
+        examples: { type: 'array', items: { type: 'string' } },
+        location: { type: 'string' },
+    },
+};
+const Message = {
+    properties: {
+        headers: 'Schema',
+        payload: (value) => {
+            if (!!value && value?.['schemaFormat']) {
+                return {
+                    properties: {
+                        schema: 'Schema',
+                        schemaFormat: { type: 'string' },
+                    },
+                    required: ['schema', 'schemaFormat'],
+                };
+            }
+            else {
+                return 'Schema';
+            }
+        },
+        correlationId: 'CorrelationId',
+        contentType: { type: 'string' },
+        name: { type: 'string' },
+        title: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        tags: 'TagList',
+        externalDocs: 'ExternalDocs',
+        bindings: 'MessageBindings',
+        examples: 'MessageExampleList',
+        traits: 'MessageTraitList',
+    },
+    additionalProperties: {},
+};
+const OperationTrait = {
+    properties: {
+        tags: 'TagList',
+        title: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        externalDocs: 'ExternalDocs',
+        security: 'SecuritySchemeList',
+        bindings: 'OperationBindings',
+    },
+    required: [],
+};
+const MessageTrait = {
+    properties: {
+        headers: (value) => {
+            if (typeof value === 'function' || (typeof value === 'object' && !!value)) {
+                return {
+                    properties: {
+                        schema: 'Schema',
+                        schemaFormat: { type: 'string' },
+                    },
+                };
+            }
+            else {
+                return 'Schema';
+            }
+        },
+        correlationId: 'CorrelationId',
+        contentType: { type: 'string' },
+        name: { type: 'string' },
+        title: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        tags: 'TagList',
+        externalDocs: 'ExternalDocs',
+        bindings: 'MessageBindings',
+        examples: 'MessageExampleList',
+    },
+    additionalProperties: {},
+};
+const Operation = {
+    properties: {
+        action: { type: 'string', enum: ['send', 'receive'] },
+        channel: 'Channel',
+        title: { type: 'string' },
+        tags: 'TagList',
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        externalDocs: 'ExternalDocs',
+        operationId: { type: 'string' },
+        security: 'SecuritySchemeList',
+        bindings: 'OperationBindings',
+        traits: 'OperationTraitList',
+        messages: 'MessageList',
+        reply: 'OperationReply',
+    },
+    required: ['action', 'channel'],
+};
+const OperationReply = {
+    properties: {
+        channel: 'Channel',
+        messages: 'MessageList',
+        address: 'OperationReplyAddress',
+    },
+};
+const OperationReplyAddress = {
+    properties: {
+        location: { type: 'string' },
+        description: { type: 'string' },
+    },
+    required: ['location'],
+};
+const Components = {
+    properties: {
+        messages: 'NamedMessages',
+        parameters: 'NamedParameters',
+        schemas: 'NamedSchemas',
+        replies: 'NamedOperationReplies',
+        replyAddresses: 'NamedOperationRelyAddresses',
+        correlationIds: 'NamedCorrelationIds',
+        messageTraits: 'NamedMessageTraits',
+        operationTraits: 'NamedOperationTraits',
+        tags: 'NamedTags',
+        externalDocs: 'NamedExternalDocs',
+        securitySchemes: 'NamedSecuritySchemes',
+        servers: 'ServerMap',
+        serverVariables: 'ServerVariablesMap',
+        channels: 'NamedChannels',
+        operations: 'NamedOperations',
+        serverBindings: 'ServerBindings',
+        channelBindings: 'ChannelBindings',
+        operationBindings: 'OperationBindings',
+        messageBindings: 'MessageBindings',
+    },
+};
+const ImplicitFlow = {
+    properties: {
+        refreshUrl: { type: 'string' },
+        availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+        authorizationUrl: { type: 'string' },
+    },
+    required: ['authorizationUrl', 'availableScopes'],
+};
+const PasswordFlow = {
+    properties: {
+        refreshUrl: { type: 'string' },
+        availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+        tokenUrl: { type: 'string' },
+    },
+    required: ['tokenUrl', 'availableScopes'],
+};
+const ClientCredentials = {
+    properties: {
+        refreshUrl: { type: 'string' },
+        availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+        tokenUrl: { type: 'string' },
+    },
+    required: ['tokenUrl', 'availableScopes'],
+};
+const AuthorizationCode = {
+    properties: {
+        refreshUrl: { type: 'string' },
+        authorizationUrl: { type: 'string' },
+        availableScopes: { type: 'object', additionalProperties: { type: 'string' } },
+        tokenUrl: { type: 'string' },
+    },
+    required: ['authorizationUrl', 'tokenUrl', 'availableScopes'],
+};
+const SecurityScheme = {
+    properties: {
+        type: {
+            enum: [
+                'userPassword',
+                'apiKey',
+                'X509',
+                'symmetricEncryption',
+                'asymmetricEncryption',
+                'httpApiKey',
+                'http',
+                'oauth2',
+                'openIdConnect',
+                'plain',
+                'scramSha256',
+                'scramSha512',
+                'gssapi',
+            ],
+        },
+        description: { type: 'string' },
+        name: { type: 'string' },
+        in: { type: 'string', enum: ['query', 'header', 'cookie', 'user', 'password'] },
+        scheme: { type: 'string' },
+        bearerFormat: { type: 'string' },
+        flows: 'SecuritySchemeFlows',
+        openIdConnectUrl: { type: 'string' },
+        scopes: { type: 'array', items: { type: 'string' } },
+    },
+    required(value) {
+        switch (value?.type) {
+            case 'apiKey':
+                return ['type', 'in'];
+            case 'httpApiKey':
+                return ['type', 'name', 'in'];
+            case 'http':
+                return ['type', 'scheme'];
+            case 'oauth2':
+                return ['type', 'flows'];
+            case 'openIdConnect':
+                return ['type', 'openIdConnectUrl'];
+            default:
+                return ['type'];
+        }
+    },
+    allowed(value) {
+        switch (value?.type) {
+            case 'apiKey':
+                return ['type', 'in', 'description'];
+            case 'httpApiKey':
+                return ['type', 'name', 'in', 'description'];
+            case 'http':
+                return ['type', 'scheme', 'bearerFormat', 'description'];
+            case 'oauth2':
+                return ['type', 'flows', 'description', 'scopes'];
+            case 'openIdConnect':
+                return ['type', 'openIdConnectUrl', 'description', 'scopes'];
+            default:
+                return ['type', 'description'];
+        }
+    },
+    extensionsPrefix: 'x-',
+};
+exports.AsyncApi3Types = {
+    // from asyncapi2
+    ...asyncapi2_1.AsyncApi2Bindings,
+    CorrelationId: asyncapi2_1.CorrelationId,
+    SecuritySchemeFlows: asyncapi2_1.SecuritySchemeFlows,
+    ServerVariable: asyncapi2_1.ServerVariable,
+    Contact: asyncapi2_1.Contact,
+    License: asyncapi2_1.License,
+    MessageExample: asyncapi2_1.MessageExample,
+    Tag: asyncapi2_1.Tag,
+    Dependencies: asyncapi2_1.Dependencies,
+    Schema: asyncapi2_1.Schema,
+    Discriminator: asyncapi2_1.Discriminator,
+    DiscriminatorMapping: asyncapi2_1.DiscriminatorMapping,
+    SchemaProperties: asyncapi2_1.SchemaProperties,
+    ServerMap: asyncapi2_1.ServerMap,
+    ExternalDocs: asyncapi2_1.ExternalDocs,
+    Root,
+    Channel,
+    Parameter,
+    Info,
+    Server,
+    MessageTrait,
+    Operation,
+    OperationReply,
+    OperationReplyAddress,
+    Components,
+    ImplicitFlow,
+    PasswordFlow,
+    ClientCredentials,
+    AuthorizationCode,
+    SecurityScheme,
+    Message,
+    OperationTrait,
+    ServerVariablesMap: (0, _1.mapOf)('ServerVariable'),
+    NamedTags: (0, _1.mapOf)('Tag'),
+    NamedExternalDocs: (0, _1.mapOf)('ExternalDocs'),
+    NamedChannels: (0, _1.mapOf)('Channel'),
+    ParametersMap: (0, _1.mapOf)('Parameter'),
+    NamedOperations: (0, _1.mapOf)('Operation'),
+    NamedOperationReplies: (0, _1.mapOf)('OperationReply'),
+    NamedOperationRelyAddresses: (0, _1.mapOf)('OperationReplyAddress'),
+    NamedSchemas: (0, _1.mapOf)('Schema'),
+    NamedMessages: (0, _1.mapOf)('Message'),
+    NamedMessageTraits: (0, _1.mapOf)('MessageTrait'),
+    NamedOperationTraits: (0, _1.mapOf)('OperationTrait'),
+    NamedParameters: (0, _1.mapOf)('Parameter'),
+    NamedSecuritySchemes: (0, _1.mapOf)('SecurityScheme'),
+    NamedCorrelationIds: (0, _1.mapOf)('CorrelationId'),
+    ServerList: (0, _1.listOf)('Server'),
+    SecuritySchemeList: (0, _1.listOf)('SecurityScheme'),
+    MessageList: (0, _1.listOf)('Message'),
+    OperationTraitList: (0, _1.listOf)('OperationTrait'),
+    MessageTraitList: (0, _1.listOf)('MessageTrait'),
+    MessageExampleList: (0, _1.listOf)('MessageExample'),
+    TagList: (0, _1.listOf)('Tag'),
+};

package/lib/types/index.d.ts

@@ -0,0 +1,57 @@
+export type ScalarSchema = {
+    name?: never;
+    type?: 'string' | 'boolean' | 'number' | 'integer' | 'object' | 'array';
+    items?: ScalarSchema;
+    enum?: string[];
+    isExample?: boolean;
+    directResolveAs?: string;
+    minimum?: number;
+};
+export type NormalizedScalarSchema = {
+    name?: never;
+    type?: 'string' | 'boolean' | 'number' | 'integer' | 'object' | 'array';
+    items?: ScalarSchema;
+    enum?: string[];
+    directResolveAs?: NormalizedNodeType;
+    resolvable: boolean;
+    minimum?: number;
+};
+export type NodeType = {
+    properties: Record<string, PropType | ResolveTypeFn>;
+    additionalProperties?: PropType | ResolveTypeFn;
+    items?: PropType | ResolveTypeFn;
+    required?: string[] | ((value: any, key: string | number | undefined) => string[]);
+    requiredOneOf?: string[];
+    allowed?: (value: any) => string[] | undefined;
+    extensionsPrefix?: string;
+};
+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?: NormalizedPropType | NormalizedResolveTypeFn;
+    required?: string[] | ((value: any, key: string | number | undefined) => string[]);
+    requiredOneOf?: string[];
+    allowed?: (value: any) => string[] | undefined;
+    extensionsPrefix?: string;
+};
+type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | null | undefined;
+type NormalizedResolveTypeFn = (value: any, key: string) => NormalizedPropType;
+export declare function listOf(typeName: string): {
+    name: string;
+    properties: {};
+    items: string;
+};
+export declare function mapOf(typeName: string): {
+    name: string;
+    properties: {};
+    additionalProperties: () => string;
+};
+export declare const SpecExtension: NormalizedNodeType;
+export declare function normalizeTypes(types: Record<string, NodeType>, options?: {
+    doNotResolveExamples?: boolean;
+}): Record<string, NormalizedNodeType>;
+export declare function isNamedType(t: NormalizedPropType): t is NormalizedNodeType;
+export {};

package/lib/types/index.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecExtension = void 0;
+exports.listOf = listOf;
+exports.mapOf = mapOf;
+exports.normalizeTypes = normalizeTypes;
+exports.isNamedType = isNamedType;
+function listOf(typeName) {
+    return {
+        name: `${typeName}List`,
+        properties: {},
+        items: typeName,
+    };
+}
+function mapOf(typeName) {
+    return {
+        name: `${typeName}Map`,
+        properties: {},
+        additionalProperties: () => typeName,
+    };
+}
+exports.SpecExtension = {
+    name: 'SpecExtension',
+    properties: {},
+    // skip validation of additional properties for unknown extensions
+    additionalProperties: { resolvable: true },
+};
+function normalizeTypes(types, options = {}) {
+    const normalizedTypes = {};
+    for (const typeName of Object.keys(types)) {
+        normalizedTypes[typeName] = {
+            ...types[typeName],
+            name: typeName,
+        };
+    }
+    for (const type of Object.values(normalizedTypes)) {
+        normalizeType(type);
+    }
+    // all type trees have a SpecExtension type by default
+    normalizedTypes['SpecExtension'] = exports.SpecExtension;
+    return normalizedTypes;
+    function normalizeType(type) {
+        if (type.additionalProperties) {
+            type.additionalProperties = resolveType(type.additionalProperties);
+        }
+        if (type.items) {
+            type.items = resolveType(type.items);
+        }
+        if (type.properties) {
+            const mappedProps = {};
+            for (const [propName, prop] of Object.entries(type.properties)) {
+                mappedProps[propName] = resolveType(prop);
+                if (options.doNotResolveExamples && prop && prop.isExample) {
+                    mappedProps[propName] = {
+                        ...prop,
+                        resolvable: false,
+                    };
+                }
+            }
+            type.properties = mappedProps;
+        }
+    }
+    // typings are painful here...
+    function resolveType(type) {
+        if (typeof type === 'string') {
+            if (!normalizedTypes[type]) {
+                throw new Error(`Unknown type name found: ${type}`);
+            }
+            return normalizedTypes[type];
+        }
+        else if (typeof type === 'function') {
+            return (value, key) => {
+                return resolveType(type(value, key));
+            };
+        }
+        else if (type && type.name) {
+            type = { ...type };
+            normalizeType(type);
+            return type;
+        }
+        else if (type && type.directResolveAs) {
+            return {
+                ...type,
+                directResolveAs: resolveType(type.directResolveAs),
+            };
+        }
+        else {
+            return type;
+        }
+    }
+}
+function isNamedType(t) {
+    return typeof t?.name === 'string';
+}

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

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

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

@@ -0,0 +1,159 @@
+"use strict";
+// For internal usage only
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeTypesFromJSONSchema = getNodeTypesFromJSONSchema;
+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) {
+    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 ((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 = schema.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;
+                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;
+}

package/lib/types/oas2.d.ts

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