@mintlify/validation 0.1.491 → 0.1.493

package/dist/openapi/v2/mapExample.d.ts

@@ -0,0 +1,8 @@
+import { ExampleOrRefObject, RefUuidMap, UUIDObjectHashMap, HashedNodeMap, UUID } from './types/index.js';
+export declare const mapExample: ({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+    example: ExampleOrRefObject;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+    uuid: UUID;
+}) => void;

package/dist/openapi/v2/mapExample.js

@@ -0,0 +1,20 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+export const mapExample = ({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const objectHash = hash(example);
+    uuidObjectHashMap[uuid] = objectHash;
+    // if we've seen this exact object before, skip processing
+    if (objectHash in hashedNodeMap) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        example = objectHash;
+        return;
+    }
+    // if ref, replace with uuid
+    if ('$ref' in example) {
+        const refId = example.$ref;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        example.$ref = refUuid;
+    }
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = example;
+};

package/dist/openapi/v2/mapHeader.d.ts

@@ -0,0 +1,8 @@
+import { HashedNodeMap, HeaderOrRefObject, RefUuidMap, UUIDObjectHashMap, UUID } from './types/index.js';
+export declare const mapHeader: ({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+    header: HeaderOrRefObject;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+    uuid: UUID;
+}) => void;

package/dist/openapi/v2/mapHeader.js

@@ -0,0 +1,57 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapExample } from './mapExample.js';
+import { mapMedia } from './mapMedia.js';
+import { mapSchema } from './mapSchema.js';
+export const mapHeader = ({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    // hash the raw object
+    const objectHash = hash(header);
+    // map uuid and hash to uuidObjectHashMap
+    uuidObjectHashMap[uuid] = objectHash;
+    // if ref, replace with uuid
+    if ('$ref' in header) {
+        const refId = header.$ref;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        header.$ref = refUuid;
+    }
+    // if not ref
+    // if schema in header, create SchemaOrRef node
+    if ('schema' in header && header.schema && typeof header.schema === 'object') {
+        const uuid = uuidv4();
+        mapSchema({
+            schema: header.schema,
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        header.schema = uuid;
+    }
+    // if examples in header, create ExampleOrRef node
+    if ('examples' in header && header.examples && typeof header.examples === 'object') {
+        Object.entries(header.examples).forEach(([exampleName, example]) => {
+            const uuid = uuidv4();
+            mapExample({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (header.examples) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                header.examples[exampleName] = uuid;
+            }
+        });
+    }
+    // if content in header, create Media node
+    if ('content' in header && header.content && typeof header.content === 'object') {
+        Object.entries(header.content).forEach(([contentType, content]) => {
+            const uuid = uuidv4();
+            mapMedia({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (header.content) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                header.content[contentType] = uuid;
+            }
+        });
+    }
+    // if encoding in header, create Encoding node
+    // TODO: add support for encoding
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = header;
+};

package/dist/openapi/v2/mapMedia.d.ts

@@ -0,0 +1,8 @@
+import { HashedNodeMap, MediaObject, RefUuidMap, UUIDObjectHashMap, UUID } from './types/index.js';
+export declare const mapMedia: ({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+    content: MediaObject;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+    uuid: UUID;
+}) => void;

package/dist/openapi/v2/mapMedia.js

@@ -0,0 +1,36 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapExample } from './mapExample.js';
+import { mapSchema } from './mapSchema.js';
+export const mapMedia = ({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const objectHash = hash(content);
+    uuidObjectHashMap[uuid] = objectHash;
+    // if we've seen this exact object before, skip processing
+    if (objectHash in hashedNodeMap) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        content = objectHash;
+        return;
+    }
+    // if schema in media, create SchemaOrRef node
+    if ('schema' in content && content.schema && typeof content.schema === 'object') {
+        const uuid = uuidv4();
+        mapSchema({ schema: content.schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        content.schema = uuid;
+    }
+    // if examples in media, create ExampleOrRef node
+    if ('examples' in content && content.examples && typeof content.examples === 'object') {
+        Object.entries(content.examples).forEach(([exampleName, example]) => {
+            const uuid = uuidv4();
+            mapExample({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (content.examples) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                content.examples[exampleName] = uuid;
+            }
+        });
+    }
+    // if encoding in media, create Encoding node
+    // TODO: add support for encoding
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = content;
+};

package/dist/openapi/v2/mapResponseComponents.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { RefUuidMap, UUIDObjectHashMap, HashedNodeMap } from './types/index.js';
+export declare const mapResponseComponents: ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }: {
+    spec: OpenAPIV3.Document | OpenAPIV3_1.Document;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+}) => void;

package/dist/openapi/v2/mapResponseComponents.js

@@ -0,0 +1,51 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapHeader } from './mapHeader.js';
+import { mapMedia } from './mapMedia.js';
+export const mapResponseComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const responseComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.responses;
+    if (!responseComponents)
+        return;
+    // for each response component
+    Object.entries(responseComponents).forEach(([responseName, response]) => {
+        // match the refId to uuid
+        const refId = `#/components/responses/${responseName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        // hash the raw object
+        const objectHash = hash(response);
+        // map uuid and hash to uuidObjectHashMap
+        uuidObjectHashMap[uuid] = objectHash;
+        // if ref, replace with uuid
+        if ('$ref' in response) {
+            const refId = response.$ref;
+            const uuid = refUuidMap[refId] || uuidv4();
+            response.$ref = uuid;
+        }
+        // if not ref
+        // if headers, convert headers to HeaderOrRef nodes
+        if ('headers' in response && response.headers && typeof response.headers === 'object') {
+            Object.entries(response.headers).forEach(([headerName, header]) => {
+                const uuid = uuidv4();
+                mapHeader({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+                if (response.headers) {
+                    response.headers[headerName] = uuid;
+                }
+            });
+        }
+        // if content, convert content to Media nodes
+        if ('content' in response && response.content && typeof response.content === 'object') {
+            Object.entries(response.content).forEach(([contentType, content]) => {
+                const uuid = uuidv4();
+                mapMedia({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+                if (response.content) {
+                    response.content[contentType] = uuid;
+                }
+            });
+        }
+        // if links, convert links to Link nodes
+        // TODO: add support for links
+        // add to hashedNodeMap
+        hashedNodeMap[objectHash] = response;
+    });
+};

package/dist/openapi/v2/mapSchema.d.ts

@@ -0,0 +1,8 @@
+import { SchemaOrRefObject, RefUuidMap, UUIDObjectHashMap, HashedNodeMap, UUID } from './types/index.js';
+export declare const mapSchema: ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+    schema: SchemaOrRefObject;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+    uuid: UUID;
+}) => void;

package/dist/openapi/v2/mapSchema.js

@@ -0,0 +1,15 @@
+import hash from 'object-hash';
+import { replaceSchemaRefs } from './replaceSchemaRefs.js';
+export const mapSchema = ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const objectHash = hash(schema);
+    uuidObjectHashMap[uuid] = objectHash;
+    // if objectHash already exists, replace with hash ref
+    if (objectHash in hashedNodeMap) {
+        // if we found a duplicate hash we can assume the schema has already been processed to remove refs, so we can quit here and don't need to process it again or add a new entry
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        schema = objectHash;
+        return;
+    }
+    replaceSchemaRefs({ schema, refUuidMap });
+    hashedNodeMap[objectHash] = schema;
+};

package/dist/openapi/v2/mapSchemaComponents.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { RefUuidMap, UUIDObjectHashMap, HashedNodeMap } from './types/index.js';
+export declare const mapSchemaComponents: ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }: {
+    spec: OpenAPIV3.Document | OpenAPIV3_1.Document;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+}) => void;

package/dist/openapi/v2/mapSchemaComponents.js

@@ -0,0 +1,22 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { replaceSchemaRefs } from './replaceSchemaRefs.js';
+export const mapSchemaComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const schemaComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.schemas;
+    if (!schemaComponents)
+        return;
+    Object.entries(schemaComponents).forEach(([schemaName, schema]) => {
+        // match the refId to uuid
+        const refId = `#/components/schemas/${schemaName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        // hash the raw object
+        const objectHash = hash(schema);
+        // map uuid and hash to uuidObjectHashMap
+        uuidObjectHashMap[uuid] = objectHash;
+        // replace refs in schema nodes with uuids
+        replaceSchemaRefs({ schema, refUuidMap });
+        // add to hashedNodeMap
+        hashedNodeMap[objectHash] = schema;
+    });
+};

package/dist/openapi/v2/openApiToSchemaGraph.js

@@ -1,4 +1,6 @@
 import { buildRefUuidMap } from './buildRefUuidMap.js';
+import { mapResponseComponents } from './mapResponseComponents.js';
+import { mapSchemaComponents } from './mapSchemaComponents.js';
 export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, }) => {
     // build map of component refs -> uuids
     // eslint-disable-next-line unused-imports/no-unused-vars
@@ -16,11 +18,13 @@ export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, })
     // add to uuid and object hash maps
     // (starting with the components section, which already have uuids in refUuidMap)
     // document.components.schemas -> Schema
-    // document.components.responses -> Response, possibly Parameter, Schema, Example, Media, Encoding
+    mapSchemaComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+    // document.components.responses -> Response, possibly Header, Schema, Example, Media, Encoding
+    mapResponseComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.parameters -> Parameter, possibly Schema, Example, Media, Encoding
     // document.components.examples -> Example
     // document.components.requestBodies -> RequestBody, possibly Media, Schema, Example, Encoding
-    // document.components.headers -> Parameter, possibly Schema, Example, Media, Encoding
+    // document.components.headers -> Header, possibly Schema, Example, Media, Encoding
     // document.components.securitySchemes -> SecurityScheme
     // document.components.links -> TODO (unsupported)
     // document.components.callbacks -> TODO (unsupported)

package/dist/openapi/v2/replaceSchemaRefs.d.ts

@@ -0,0 +1,5 @@
+import { RefUuidMap, SchemaOrRefObject } from './types/index.js';
+export declare const replaceSchemaRefs: ({ schema, refUuidMap, }: {
+    schema: SchemaOrRefObject;
+    refUuidMap: RefUuidMap;
+}) => void;

package/dist/openapi/v2/replaceSchemaRefs.js

@@ -0,0 +1,34 @@
+import { v4 as uuidv4 } from 'uuid';
+export const replaceSchemaRefs = ({ schema, refUuidMap, }) => {
+    if ('$ref' in schema) {
+        const refId = schema.$ref;
+        const uuid = refUuidMap[refId] || uuidv4();
+        schema.$ref = uuid;
+    }
+    if ('properties' in schema && schema.properties && typeof schema.properties === 'object') {
+        Object.values(schema.properties).forEach((subschema) => {
+            replaceSchemaRefs({ schema: subschema, refUuidMap });
+        });
+    }
+    if ('items' in schema && schema.items && typeof schema.items === 'object') {
+        replaceSchemaRefs({ schema: schema.items, refUuidMap });
+    }
+    if ('oneOf' in schema && schema.oneOf && Array.isArray(schema.oneOf)) {
+        schema.oneOf.forEach((subschema) => {
+            replaceSchemaRefs({ schema: subschema, refUuidMap });
+        });
+    }
+    if ('anyOf' in schema && schema.anyOf && Array.isArray(schema.anyOf)) {
+        schema.anyOf.forEach((subschema) => {
+            replaceSchemaRefs({ schema: subschema, refUuidMap });
+        });
+    }
+    if ('allOf' in schema && schema.allOf && Array.isArray(schema.allOf)) {
+        schema.allOf.forEach((subschema) => {
+            replaceSchemaRefs({ schema: subschema, refUuidMap });
+        });
+    }
+    if ('not' in schema && schema.not && typeof schema.not === 'object') {
+        replaceSchemaRefs({ schema: schema.not, refUuidMap });
+    }
+};

package/dist/openapi/v2/types/index.d.ts

@@ -1,14 +1,15 @@
 import { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
 import { XMcp, XMint } from '../../types/endpoint.js';
 export type UUID = string;
-export type objectHash = string;
+export type HashId = string;
 export type RefUuidMap = Record<string, UUID>;
-export type UUIDObjectHashMap = Record<UUID, objectHash>;
-export type HashedNodeMap = Record<objectHash, GraphNode>;
-export type GraphNode = Schema | Response | Parameter | Example | RequestBody | SecurityScheme | Media | Encoding;
+export type UUIDObjectHashMap = Record<UUID, HashId>;
+export type HashedNodeMap = Record<HashId, GraphNode>;
+export type GraphNode = SchemaOrRef | ResponseOrRef | HeaderOrRef | ParameterOrRef | Media | ExampleOrRef | RequestBodyOrRef | SecurityScheme | Server | Path | Operation | SecurityRequirement | Document;
 export type SchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
-export type Schema = SchemaObject & {
-    type: 'schema';
+export type RefObject = OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+export type SchemaOrRefObject = SchemaObject | RefObject;
+export type SchemaOrRef = (SchemaOrRefObject & {
     items?: UUID;
     properties?: {
         [name: string]: UUID;
@@ -18,68 +19,79 @@ export type Schema = SchemaObject & {
     anyOf?: UUID[];
     oneOf?: UUID[];
     not?: UUID;
-};
+}) | (RefObject & {
+    $ref: UUID;
+}) | HashId;
 export type ResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
-export type Response = ResponseObject & {
-    type: 'response';
+export type ResponseOrRef = (ResponseObject & {
     headers?: {
         [header: string]: UUID;
     };
     content?: {
-        [mediaType: string]: UUID;
+        [contentType: string]: UUID;
     };
-};
+    links?: {
+        [link: string]: UUID;
+    };
+}) | (RefObject & {
+    $ref: UUID;
+});
+export type HeaderObject = OpenAPIV3.HeaderObject | OpenAPIV3_1.HeaderObject;
+export type HeaderOrRefObject = HeaderObject | RefObject;
+export type HeaderOrRef = (HeaderObject & {
+    schema?: UUID;
+    examples?: {
+        [name: string]: UUID;
+    };
+    content?: {
+        [contentType: string]: UUID;
+    };
+}) | (RefObject & {
+    $ref: UUID;
+});
 export type ParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
-export type Parameter = ParameterObject & {
-    type: 'parameter';
+export type ParameterOrRefObject = ParameterObject | RefObject;
+export type ParameterOrRef = (ParameterObject & {
     schema?: UUID;
     examples?: {
-        [media: string]: UUID;
+        [name: string]: UUID;
     };
     content?: {
-        [media: string]: UUID;
+        [contentType: string]: UUID;
     };
-};
+}) | (RefObject & {
+    $ref: UUID;
+});
 export type MediaObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
 export type Media = MediaObject & {
-    type: 'media';
     schema?: UUID;
     examples?: {
-        [media: string]: UUID;
+        [name: string]: UUID;
     };
     encoding?: {
         [encoding: string]: UUID;
     };
 };
-export type EncodingObject = OpenAPIV3.EncodingObject | OpenAPIV3_1.EncodingObject;
-export type Encoding = EncodingObject & {
-    type: 'encoding';
-    headers?: {
-        [header: string]: UUID;
-    };
-};
 export type ExampleObject = OpenAPIV3.ExampleObject | OpenAPIV3_1.ExampleObject;
-export type Example = ExampleObject & {
-    type: 'example';
-};
+export type ExampleOrRefObject = ExampleObject | RefObject;
+export type ExampleOrRef = ExampleObject | (RefObject & {
+    $ref: UUID;
+});
 export type RequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
-export type RequestBody = RequestBodyObject & {
-    type: 'requestBody';
+export type RequestBodyOrRefObject = RequestBodyObject | RefObject;
+export type RequestBodyOrRef = (RequestBodyObject & {
     content?: {
-        [media: string]: UUID;
+        [contentType: string]: UUID;
     };
-};
+}) | (RefObject & {
+    $ref: UUID;
+});
 export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject | OpenAPIV3_1.SecuritySchemeObject;
-export type SecurityScheme = SecuritySchemeObject & {
-    type: 'securityScheme';
-};
+export type SecurityScheme = SecuritySchemeObject;
 export type ServerObject = OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject;
-export type Server = ServerObject & {
-    type: 'server';
-};
+export type Server = ServerObject;
 export type PathObject = OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject;
 export type Path = PathObject & {
-    type: 'path';
     pattern: string;
     parameters?: UUID[];
 } & {
@@ -95,7 +107,6 @@ export type OperationExtensions = {
     'x-code-samples'?: string[];
 };
 export type Operation = OperationObject & {
-    type: 'operation';
     parameters?: UUID[];
     requestBody?: UUID;
     responses?: {
@@ -108,12 +119,9 @@ export type Operation = OperationObject & {
     servers?: UUID[];
 } & OperationExtensions;
 export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject | OpenAPIV3_1.SecurityRequirementObject;
-export type SecurityRequirement = SecurityRequirementObject & {
-    type: 'securityRequirement';
-};
+export type SecurityRequirement = SecurityRequirementObject;
 export type DocumentObject = OpenAPIV3.Document | OpenAPIV3_1.Document;
 export type Document = DocumentObject & {
-    type: 'document';
     servers?: UUID[];
     paths?: UUID[];
     webhooks?: UUID[];