@mintlify/validation 0.1.492 → 0.1.494

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/mapExampleComponents.d.ts

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

package/dist/openapi/v2/mapExampleComponents.js

@@ -0,0 +1,15 @@
+import { v4 as uuidv4 } from 'uuid';
+import { mapExample } from './mapExample.js';
+export const mapExampleComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const exampleComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.examples;
+    if (!exampleComponents)
+        return;
+    // for each example component
+    Object.entries(exampleComponents).forEach(([exampleName, example]) => {
+        // match the refId to uuid
+        const refId = `#/components/examples/${exampleName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        mapExample({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+    });
+};

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/mapHeaderComponents.d.ts

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

package/dist/openapi/v2/mapHeaderComponents.js

@@ -0,0 +1,13 @@
+import { v4 as uuidv4 } from 'uuid';
+import { mapHeader } from './mapHeader.js';
+export const mapHeaderComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const headerComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.headers;
+    if (!headerComponents)
+        return;
+    Object.entries(headerComponents).forEach(([headerName, header]) => {
+        const refId = `#/components/headers/${headerName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        mapHeader({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+    });
+};

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/mapParameter.d.ts

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

package/dist/openapi/v2/mapParameter.js

@@ -0,0 +1,53 @@
+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 mapParameter = ({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const objectHash = hash(parameter);
+    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
+        parameter = objectHash;
+        return;
+    }
+    // if ref, replace with uuid
+    if ('$ref' in parameter) {
+        const refId = parameter.$ref;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        parameter.$ref = refUuid;
+    }
+    // if not ref
+    // if schema in parameter, create SchemaOrRef node
+    if ('schema' in parameter && parameter.schema && typeof parameter.schema === 'object') {
+        const uuid = uuidv4();
+        mapSchema({ schema: parameter.schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parameter.schema = uuid;
+    }
+    // if examples in parameter, create ExampleOrRef node
+    if ('examples' in parameter && parameter.examples && typeof parameter.examples === 'object') {
+        Object.entries(parameter.examples).forEach(([exampleName, example]) => {
+            const uuid = uuidv4();
+            mapExample({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (parameter.examples) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                parameter.examples[exampleName] = uuid;
+            }
+        });
+    }
+    // if content in parameter, create Media node
+    if ('content' in parameter && parameter.content && typeof parameter.content === 'object') {
+        Object.entries(parameter.content).forEach(([contentType, content]) => {
+            const uuid = uuidv4();
+            mapMedia({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (parameter.content) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                parameter.content[contentType] = uuid;
+            }
+        });
+    }
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = parameter;
+};

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

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

package/dist/openapi/v2/mapParameterComponents.js

@@ -0,0 +1,20 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapParameter } from './mapParameter.js';
+export const mapParameterComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const parameterComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.parameters;
+    if (!parameterComponents)
+        return;
+    // for each parameter component
+    Object.entries(parameterComponents).forEach(([parameterName, parameter]) => {
+        // match the refId to uuid
+        const refId = `#/components/parameters/${parameterName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        // hash the raw object
+        const objectHash = hash(parameter);
+        // map uuid and hash to uuidObjectHashMap
+        uuidObjectHashMap[uuid] = objectHash;
+        mapParameter({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+    });
+};

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

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

package/dist/openapi/v2/mapRequestBody.js

@@ -0,0 +1,31 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapMedia } from './mapMedia.js';
+export const mapRequestBody = ({ requestBody, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    // hash the raw object
+    const objectHash = hash(requestBody);
+    // map uuid and hash to uuidObjectHashMap
+    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
+        requestBody = objectHash;
+        return;
+    }
+    // if ref, replace with uuid
+    if ('$ref' in requestBody) {
+        const refId = requestBody.$ref;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        requestBody.$ref = refUuid;
+    }
+    // for each content in request body, create Media node
+    if ('content' in requestBody) {
+        Object.entries(requestBody.content).forEach(([contentType, content]) => {
+            const uuid = uuidv4();
+            mapMedia({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            requestBody.content[contentType] = uuid;
+        });
+    }
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = requestBody;
+};

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

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

package/dist/openapi/v2/mapRequestBodyComponents.js

@@ -0,0 +1,15 @@
+import { v4 as uuidv4 } from 'uuid';
+import { mapRequestBody } from './mapRequestBody.js';
+export const mapRequestBodyComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const requestBodyComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.requestBodies;
+    if (!requestBodyComponents)
+        return;
+    // for each request body component
+    Object.entries(requestBodyComponents).forEach(([requestBodyName, requestBody]) => {
+        // match the refId to uuid
+        const refId = `#/components/requestBodies/${requestBodyName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        mapRequestBody({ requestBody, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+    });
+};

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/mapSecuritySchemeComponents.d.ts

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

package/dist/openapi/v2/mapSecuritySchemeComponents.js

@@ -0,0 +1,20 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+export const mapSecuritySchemeComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a;
+    const securitySchemeComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.securitySchemes;
+    if (!securitySchemeComponents)
+        return;
+    Object.entries(securitySchemeComponents).forEach(([securitySchemeName, securityScheme]) => {
+        const refId = `#/components/securitySchemes/${securitySchemeName}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        const objectHash = hash(securityScheme);
+        uuidObjectHashMap[uuid] = objectHash;
+        if ('$ref' in securityScheme) {
+            const refId = securityScheme.$ref;
+            const refUuid = refUuidMap[refId] || uuidv4();
+            securityScheme.$ref = refUuid;
+        }
+        hashedNodeMap[objectHash] = securityScheme;
+    });
+};

package/dist/openapi/v2/openApiToSchemaGraph.js

@@ -1,4 +1,11 @@
 import { buildRefUuidMap } from './buildRefUuidMap.js';
+import { mapExampleComponents } from './mapExampleComponents.js';
+import { mapHeaderComponents } from './mapHeaderComponents.js';
+import { mapParameterComponents } from './mapParameterComponents.js';
+import { mapRequestBodyComponents } from './mapRequestBodyComponents.js';
+import { mapResponseComponents } from './mapResponseComponents.js';
+import { mapSchemaComponents } from './mapSchemaComponents.js';
+import { mapSecuritySchemeComponents } from './mapSecuritySchemeComponents.js';
 export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, }) => {
     // build map of component refs -> uuids
     // eslint-disable-next-line unused-imports/no-unused-vars
@@ -16,12 +23,19 @@ 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
+    mapParameterComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.examples -> Example
+    mapExampleComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.requestBodies -> RequestBody, possibly Media, Schema, Example, Encoding
-    // document.components.headers -> Parameter, possibly Schema, Example, Media, Encoding
+    mapRequestBodyComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+    // document.components.headers -> Header, possibly Schema, Example, Media, Encoding
+    mapHeaderComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.securitySchemes -> SecurityScheme
+    mapSecuritySchemeComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.links -> TODO (unsupported)
     // document.components.callbacks -> TODO (unsupported)
     // document.components.pathItems -> 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 });
+    }
+};