@mintlify/common 1.0.330 → 1.0.332

package/dist/asyncapi/getAsyncApiChannelMetadata.js

@@ -1,6 +1,6 @@
+import { camelToSentenceCase } from '../camelToSentenceCase.js';
 import { parseAsyncApiString } from './parseAsyncApiString.js';
 export const getAsyncApiChannelMetadata = (asyncApiMetaField, asyncApiFiles) => {
-    var _a, _b;
     const potentiallyParsedAsyncApiString = parseAsyncApiString(asyncApiMetaField);
     if (potentiallyParsedAsyncApiString == undefined) {
         return undefined;
@@ -9,7 +9,7 @@ export const getAsyncApiChannelMetadata = (asyncApiMetaField, asyncApiFiles) =>
     let asyncApiFile = undefined;
     for (const file of asyncApiFiles) {
         const asyncApiSpec = file.spec;
-        const hasAsyncApiChannel = asyncApiSpec.allChannels().has(channelId);
+        const hasAsyncApiChannel = channelId && asyncApiSpec.allChannels().has(channelId);
         const filenameMatches = !filename || filename === file.filename || filename === file.originalFileLocation;
         if (hasAsyncApiChannel && filenameMatches) {
             asyncApiFile = file;
@@ -18,9 +18,11 @@ export const getAsyncApiChannelMetadata = (asyncApiMetaField, asyncApiFiles) =>
     if (asyncApiFile == null) {
         return undefined;
     }
-    const channelInterface = asyncApiFile.spec.channels().get(channelId);
-    const channelTitle = (_a = channelInterface.title()) !== null && _a !== void 0 ? _a : '';
-    const channelDescription = (_b = channelInterface.description()) !== null && _b !== void 0 ? _b : '';
+    const channelInterface = channelId
+        ? asyncApiFile.spec.channels().get(channelId)
+        : undefined;
+    const channelTitle = (channelInterface === null || channelInterface === void 0 ? void 0 : channelInterface.title()) || camelToSentenceCase(channelId);
+    const channelDescription = (channelInterface === null || channelInterface === void 0 ? void 0 : channelInterface.description()) || (channelInterface === null || channelInterface === void 0 ? void 0 : channelInterface.summary()) || '';
     return {
         channelId,
         filename: asyncApiFile.filename,

package/dist/asyncapi/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getAsyncApiDocumentFromUrl.js';
+export * from './validateAsyncApi.js';
+export * from './parseAsyncApiString.js';
+export * from './parser/getChannelData.js';
+export * from './prepAsyncApiFrontmatter.js';

package/dist/asyncapi/index.js

@@ -0,0 +1,5 @@
+export * from './getAsyncApiDocumentFromUrl.js';
+export * from './validateAsyncApi.js';
+export * from './parseAsyncApiString.js';
+export * from './parser/getChannelData.js';
+export * from './prepAsyncApiFrontmatter.js';

package/dist/asyncapi/parser/extractSchemaProperties.d.ts

@@ -0,0 +1,2 @@
+import { SchemaProperty, AnyRecord } from '../../types/asyncapi.js';
+export declare const extractSchemaProperties: (schema: AnyRecord | undefined) => SchemaProperty[];

package/dist/asyncapi/parser/extractSchemaProperties.js

@@ -0,0 +1,67 @@
+export const extractSchemaProperties = (schema) => {
+    if (!schema) {
+        return [];
+    }
+    const properties = [];
+    const requiredFields = new Set(schema.required || []);
+    for (const [key, value] of Object.entries(schema)) {
+        const name = key;
+        if (name === 'required' || name.includes('x-parser')) {
+            continue;
+        }
+        if (name === 'oneOf' || name === 'anyOf' || name === 'allOf') {
+            const descriptions = {
+                oneOf: 'Must be one of these types',
+                anyOf: 'Can be any of these types',
+                allOf: 'Must contain all of these types',
+            };
+            const prop = {
+                name,
+                type: name,
+                description: descriptions[name],
+                properties: value
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    .map((item) => {
+                    const schemaWithRequired = Object.assign(Object.assign({}, (item.properties || item)), { required: item.required });
+                    const extracted = extractSchemaProperties(schemaWithRequired);
+                    return extracted;
+                })
+                    .flat(),
+            };
+            properties.push(prop);
+            continue;
+        }
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            const keys = Object.keys(value);
+            if ('type' in value || keys.some((key) => /^x-.*type$/.test(key))) {
+                const typeKey = 'type' in value ? 'type' : keys.find((key) => /^x-.*type$/.test(key));
+                const prop = {
+                    name: name,
+                    type: value[typeKey],
+                    description: value.description || value['const'],
+                    deprecated: value.deprecated,
+                    required: requiredFields.has(name),
+                };
+                if (value.properties) {
+                    prop.properties = extractSchemaProperties(value.properties);
+                }
+                properties.push(prop);
+            }
+            else {
+                properties.push(...extractSchemaProperties(value));
+            }
+        }
+        else {
+            properties.push({
+                name,
+                type: Array.isArray(value) ? 'array' : typeof value,
+                description: typeof value === 'string' ? value : undefined,
+                required: requiredFields.has(name),
+            });
+        }
+    }
+    return properties;
+};

package/dist/asyncapi/parser/getBindingsData.d.ts

@@ -0,0 +1,2 @@
+import { AsyncApiBinding, BindingInterface } from '../../types/asyncapi.js';
+export declare const getBindingsData: (bindings: BindingInterface[]) => AsyncApiBinding[];

package/dist/asyncapi/parser/getBindingsData.js

@@ -0,0 +1,12 @@
+import { extractSchemaProperties } from './extractSchemaProperties.js';
+export const getBindingsData = (bindings) => {
+    return bindings.map((binding) => {
+        const properties = extractSchemaProperties(binding.value());
+        return {
+            protocol: binding.protocol(),
+            version: binding.version(),
+            value: binding.value(),
+            schemaProperties: properties,
+        };
+    });
+};

package/dist/asyncapi/parser/getChannelData.d.ts

@@ -0,0 +1,7 @@
+import { AsyncAPIDocumentInterface, ChannelData } from '../../types/asyncapi.js';
+type GetChannelDataParams = {
+    document: AsyncAPIDocumentInterface;
+    channelId: string | undefined;
+};
+export declare const getChannelData: ({ document, channelId, }: GetChannelDataParams) => ChannelData | undefined;
+export {};

package/dist/asyncapi/parser/getChannelData.js

@@ -0,0 +1,57 @@
+import { camelToSentenceCase } from '../../camelToSentenceCase.js';
+import { getBindingsData } from './getBindingsData.js';
+import { getExtensionsData } from './getExtensionsData.js';
+import { getOperationsData } from './getOperationsData.js';
+import { getParametersData } from './getParametersData.js';
+import { getSecuritySchemesData } from './getSecuritySchemesData.js';
+import { getServersData } from './getServersData.js';
+export const getChannelData = ({ document, channelId, }) => {
+    if (!channelId)
+        return undefined;
+    const channel = document.channels().get(channelId);
+    if (!channel)
+        return undefined;
+    const title = channel.title() || camelToSentenceCase(channelId);
+    const description = channel.description() || channel.summary() || '';
+    const servers = getServersData(channel.servers().all());
+    const address = channel.address();
+    const parameters = getParametersData(channel);
+    const bindings = getBindingsData(channel.bindings().all());
+    const extensions = getExtensionsData(channel.extensions().all());
+    const { operations, sendOperations, receiveOperations, sendMessages, receiveMessages } = getOperationsAndMessagesData(channel);
+    const securitySchemes = getSecuritySchemesData(document.securitySchemes().all());
+    return {
+        id: channelId,
+        title,
+        description,
+        servers,
+        address,
+        parameters,
+        bindings,
+        operations,
+        sendOperations,
+        receiveOperations,
+        sendMessages,
+        receiveMessages,
+        extensions,
+        securitySchemes,
+    };
+};
+const getOperationsAndMessagesData = (channel) => {
+    const operations = channel.operations().all();
+    const extensions = getExtensionsData(channel.extensions().all());
+    const allOperations = getOperationsData(operations, extensions);
+    // the schema defines "send" and "receive" as whether the _websocket_ sends or receives messages
+    // we need to flip them from the perspective of the user, so that "send" messages are ones the user sends and the websocket receives, and "receive" is the user receiving messages the websocket sends
+    const sendOperations = allOperations.filter(({ type }) => type === 'receive');
+    const receiveOperations = allOperations.filter(({ type }) => type === 'send');
+    const sendMessages = sendOperations.flatMap(({ messages }) => messages);
+    const receiveMessages = receiveOperations.flatMap(({ messages }) => messages);
+    return {
+        operations: allOperations,
+        sendOperations,
+        receiveOperations,
+        sendMessages,
+        receiveMessages,
+    };
+};

package/dist/asyncapi/parser/getExamplesData.d.ts

@@ -0,0 +1,6 @@
+import { MessageInterface, AnyRecord, AsyncApiExtension } from '../../types/asyncapi.js';
+export declare const getExamplesData: ({ message, payloadSchema, extensions, }: {
+    message: MessageInterface;
+    payloadSchema: AnyRecord;
+    extensions: AsyncApiExtension[];
+}) => string;

package/dist/asyncapi/parser/getExamplesData.js

@@ -0,0 +1,68 @@
+import { generateExampleFromSchema } from '@mintlify/validation';
+export const getExamplesData = ({ message, payloadSchema, extensions, }) => {
+    var _a, _b;
+    const id = message.id().toLowerCase();
+    const examples = message.examples();
+    const hasInlineExamples = examples.length > 0;
+    if (hasInlineExamples) {
+        const example = (_b = (_a = examples[0]) === null || _a === void 0 ? void 0 : _a['_json']) === null || _b === void 0 ? void 0 : _b['payload'];
+        return JSON.stringify(example, null, 2);
+    }
+    const extensionExamples = createMessageExamplesMap(extensions);
+    const hasExtensionExamples = extensionExamples.has(id);
+    if (hasExtensionExamples) {
+        return JSON.stringify(extensionExamples.get(id), null, 2);
+    }
+    const generatedExample = generateMessageExample(payloadSchema);
+    return JSON.stringify(generatedExample, null, 2);
+};
+const generateMessageExample = (payloadSchema) => {
+    const schema = {
+        type: 'object',
+        properties: payloadSchema.reduce((acc, schema) => {
+            if (schema.properties) {
+                return Object.assign(Object.assign({}, acc), schema.properties.reduce((props, prop) => {
+                    if (prop.properties) {
+                        return Object.assign(Object.assign({}, props), { [prop.name]: [
+                                {
+                                    type: 'object',
+                                    properties: prop.properties.reduce((nestedProps, nestedProp) => (Object.assign(Object.assign({}, nestedProps), { [nestedProp.name]: [
+                                            {
+                                                type: nestedProp.type,
+                                                required: nestedProp.required,
+                                                description: nestedProp.description,
+                                            },
+                                        ] })), {}),
+                                },
+                            ] });
+                    }
+                    return Object.assign(Object.assign({}, props), { [prop.name]: [
+                            {
+                                type: prop.type,
+                                required: prop.required,
+                                description: prop.description,
+                            },
+                        ] });
+                }, {}));
+            }
+            return acc;
+        }, {}),
+    };
+    const example = generateExampleFromSchema(schema, 0);
+    return example;
+};
+const createMessageExamplesMap = (extensions) => {
+    const examplesMap = new Map();
+    const examplesExt = extensions.find((ext) => ext.id.match(/^x-.*examples$/));
+    if (!examplesExt)
+        return examplesMap;
+    examplesExt.value.forEach((item) => {
+        item.messages.forEach((message) => {
+            const id = message.messageId.toLowerCase();
+            examplesMap.set(id, {
+                value: message.value,
+            });
+        });
+    });
+    return examplesMap;
+};

package/dist/asyncapi/parser/getExtensionsData.d.ts

@@ -0,0 +1,2 @@
+import { AsyncApiExtension, ExtensionInterface } from '../../types/asyncapi.js';
+export declare const getExtensionsData: (extensions: ExtensionInterface[]) => AsyncApiExtension[];

package/dist/asyncapi/parser/getExtensionsData.js

@@ -0,0 +1,8 @@
+export const getExtensionsData = (extensions) => {
+    return extensions.map((extension) => {
+        return {
+            id: extension.id(),
+            value: extension.value(),
+        };
+    });
+};

package/dist/asyncapi/parser/getMessagesData.d.ts

@@ -0,0 +1,8 @@
+import { AnyRecord, AsyncApiMessage, AsyncApiExtension, MessageInterface } from '../../types/asyncapi.js';
+export declare const getMessagesData: (messages: MessageInterface[], extensions: AsyncApiExtension[]) => AsyncApiMessage[];
+export declare const getMessagePayloadSchema: (title: string, description: string | undefined, payload: AnyRecord) => {
+    name: string;
+    description: string | undefined;
+    type: string | undefined;
+    properties: import("../../types/asyncapi.js").SchemaProperty[] | undefined;
+}[];

package/dist/asyncapi/parser/getMessagesData.js

@@ -0,0 +1,77 @@
+import { camelToSentenceCase } from '../../camelToSentenceCase.js';
+import { extractSchemaProperties } from './extractSchemaProperties.js';
+import { getBindingsData } from './getBindingsData.js';
+import { getExamplesData } from './getExamplesData.js';
+import { getExtensionsData } from './getExtensionsData.js';
+export const getMessagesData = (messages, extensions) => {
+    return messages.map((message) => {
+        var _a, _b, _c, _d, _e;
+        const id = message.id();
+        const title = (_b = (_a = message.title()) !== null && _a !== void 0 ? _a : message.name()) !== null && _b !== void 0 ? _b : message.id();
+        const niceTitle = title === id ? camelToSentenceCase(id) : title;
+        const description = (_c = message.summary()) !== null && _c !== void 0 ? _c : message.description();
+        const payload = (_d = message.payload()) === null || _d === void 0 ? void 0 : _d['_json'];
+        const headers = (_e = message.headers()) === null || _e === void 0 ? void 0 : _e['_json'];
+        const payloadSchema = getMessagePayloadSchema(title, description, payload);
+        const example = getExamplesData({
+            message,
+            payloadSchema,
+            extensions,
+        });
+        return {
+            id,
+            contentType: message.contentType(),
+            payload: payloadSchema,
+            headers: getMessageHeaders(headers),
+            jsonPayloadSchema: payload,
+            jsonHeadersSchema: headers,
+            title: niceTitle,
+            description,
+            example,
+            bindings: getBindingsData(message.bindings().all()),
+            extensions: getExtensionsData(message.extensions().all()),
+        };
+    });
+};
+export const getMessagePayloadSchema = (title, description, payload) => {
+    var _a, _b;
+    const schemaProperties = payload.properties || ((_a = payload['schema']) === null || _a === void 0 ? void 0 : _a.properties) || payload['schema'] || payload;
+    const schemaRequired = payload.required || ((_b = payload['schema']) === null || _b === void 0 ? void 0 : _b.required);
+    const requiredAndProperties = Object.assign(Object.assign({}, schemaProperties), { required: schemaRequired });
+    const properties = requiredAndProperties
+        ? extractSchemaProperties(requiredAndProperties)
+        : undefined;
+    const schema = [
+        {
+            name: title,
+            description,
+            type: payload.type || properties ? 'object' : undefined,
+            properties,
+        },
+    ];
+    return schema;
+};
+const getMessageHeaders = (headers) => {
+    if (!headers)
+        return [];
+    const schemaProperties = headers.properties;
+    if (!schemaProperties)
+        return [];
+    const schemaRequired = headers.required;
+    const requiredAndProperties = Object.assign(Object.assign({}, schemaProperties), { required: schemaRequired });
+    const properties = requiredAndProperties
+        ? extractSchemaProperties(requiredAndProperties)
+        : undefined;
+    const schema = [
+        {
+            name: 'headers',
+            description: undefined,
+            type: 'object',
+            properties,
+        },
+    ];
+    if (properties && properties.length > 0) {
+        return schema;
+    }
+    return [];
+};

package/dist/asyncapi/parser/getOperationsData.d.ts

@@ -0,0 +1,2 @@
+import { OperationInterface, AsyncApiExtension, AsyncApiOperation } from '../../types/asyncapi.js';
+export declare const getOperationsData: (operations: OperationInterface[], extensions: AsyncApiExtension[]) => AsyncApiOperation[];

package/dist/asyncapi/parser/getOperationsData.js

@@ -0,0 +1,24 @@
+import { camelToSentenceCase } from '../../camelToSentenceCase.js';
+import { getBindingsData } from './getBindingsData.js';
+import { getMessagesData } from './getMessagesData.js';
+export const getOperationsData = (operations, extensions) => {
+    return operations.map((operation) => {
+        var _a, _b, _c, _d;
+        const id = (_a = operation.operationId()) !== null && _a !== void 0 ? _a : operation.id();
+        const title = (_c = (_b = operation['_json']) === null || _b === void 0 ? void 0 : _b.title) !== null && _c !== void 0 ? _c : id;
+        const type = operation.action();
+        const niceTitle = id && title === id ? camelToSentenceCase(id) : title;
+        const description = (_d = operation.summary()) !== null && _d !== void 0 ? _d : operation.description();
+        const messages = getMessagesData(operation.messages().all(), extensions);
+        const bindings = getBindingsData(operation.bindings().all());
+        return {
+            id,
+            title: niceTitle,
+            description,
+            type,
+            messages,
+            bindings,
+            extensions,
+        };
+    });
+};

package/dist/asyncapi/parser/getParametersData.d.ts

@@ -0,0 +1,2 @@
+import { AsyncAPIChannel, AsyncApiParameter } from '../../types/asyncapi.js';
+export declare const getParametersData: (channel: AsyncAPIChannel) => AsyncApiParameter[];

package/dist/asyncapi/parser/getParametersData.js

@@ -0,0 +1,20 @@
+export const getParametersData = (channel) => {
+    const parameters = channel.parameters().all();
+    return parameters.map((parameter) => {
+        var _a, _b, _c;
+        const id = parameter.id();
+        const deprecated = (_a = parameter.schema()) === null || _a === void 0 ? void 0 : _a.deprecated();
+        const jsonSchema = (_b = parameter.schema()) === null || _b === void 0 ? void 0 : _b['_json'];
+        const type = jsonSchema['type'] || undefined;
+        const propertiesCount = ((_c = jsonSchema['properties']) === null || _c === void 0 ? void 0 : _c.length) || undefined;
+        return {
+            id,
+            jsonSchema,
+            description: parameter.description(),
+            type,
+            propertiesCount,
+            required: true,
+            deprecated,
+        };
+    });
+};

package/dist/asyncapi/parser/getSecuritySchemesData.d.ts

@@ -0,0 +1,2 @@
+import { AsyncApiSecurityScheme, SecuritySchemeInterface } from '../../types/asyncapi.js';
+export declare const getSecuritySchemesData: (securitySchemes: SecuritySchemeInterface[]) => AsyncApiSecurityScheme[];

package/dist/asyncapi/parser/getSecuritySchemesData.js

@@ -0,0 +1,16 @@
+import { getExtensionsData } from './getExtensionsData.js';
+export const getSecuritySchemesData = (securitySchemes) => {
+    return securitySchemes.map((securityScheme) => {
+        return {
+            id: securityScheme.id(),
+            name: securityScheme.name() || securityScheme.id(),
+            type: securityScheme.type(),
+            description: securityScheme.description(),
+            in: securityScheme.in(),
+            scheme: securityScheme.scheme(),
+            bearerFormat: securityScheme.bearerFormat(),
+            openIdConnectUrl: securityScheme.openIdConnectUrl(),
+            extensions: getExtensionsData(securityScheme.extensions().all()),
+        };
+    });
+};

package/dist/asyncapi/parser/getServersData.d.ts

@@ -0,0 +1,2 @@
+import { Server, ServerInterface } from '../../types/asyncapi.js';
+export declare const getServersData: (servers: ServerInterface[]) => Server[];

package/dist/asyncapi/parser/getServersData.js

@@ -0,0 +1,22 @@
+import { getBindingsData } from './getBindingsData.js';
+export const getServersData = (servers) => {
+    return servers.map((server) => {
+        const variables = server.variables().all();
+        const variablesData = variables.map((variable) => {
+            return {
+                id: variable.id(),
+                description: variable.description(),
+                defaultValue: variable.defaultValue(),
+                allowedValues: variable.allowedValues(),
+                examples: variable.examples(),
+            };
+        });
+        return {
+            id: server.id(),
+            protocol: server.protocol(),
+            host: server.host(),
+            bindings: getBindingsData(server.bindings().all()),
+            variables: variablesData,
+        };
+    });
+};

package/dist/index.d.ts

@@ -15,5 +15,4 @@ export * from './divisions/index.js';
 export * from './title.js';
 export * from './schema/common.js';
 export * from './camelToSentenceCase.js';
-export * from './asyncapi/getAsyncApiDocumentFromUrl.js';
-export * from './asyncapi/validateAsyncApi.js';
+export * from './asyncapi/index.js';

package/dist/index.js

@@ -15,5 +15,4 @@ export * from './divisions/index.js';
 export * from './title.js';
 export * from './schema/common.js';
 export * from './camelToSentenceCase.js';
-export * from './asyncapi/getAsyncApiDocumentFromUrl.js';
-export * from './asyncapi/validateAsyncApi.js';
+export * from './asyncapi/index.js';