@mintlify/validation 0.1.494 → 0.1.496

package/dist/mint-config/schemas/v2/properties/navigation/products.js

@@ -6,6 +6,7 @@ import { hrefSchema } from '../reusable/href.js';
 import { iconSchema } from '../reusable/icon.js';
 import { openApiSchema } from '../reusable/openapi.js';
 import { anchorsSchema, decoratedAnchorsSchema } from './anchors.js';
+import { decoratedDropdownsSchema, dropdownsSchema } from './dropdown.js';
 import { globalSchema } from './global.js';
 import { groupsSchema, decoratedGroupsSchema } from './groups.js';
 import { languagesSchema, decoratedLanguagesSchema } from './languages.js';
@@ -51,6 +52,12 @@ export const productSchema = z.union([
         asyncapi: asyncApiSchema.optional(),
         global: z.lazy(() => globalSchema).optional(),
     }),
+    baseProductSchema.extend({
+        dropdowns: z.lazy(() => dropdownsSchema),
+        openapi: openApiSchema.optional(),
+        asyncapi: asyncApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
     baseProductSchema.extend({
         groups: z.lazy(() => groupsSchema),
         openapi: openApiSchema.optional(),
@@ -75,6 +82,7 @@ export const decoratedProductSchema = baseProductSchema.and(z.union([
     z.lazy(() => z.object({ versions: decoratedVersionsSchema, global: globalSchema.optional() })),
     z.lazy(() => z.object({ tabs: decoratedTabsSchema, global: globalSchema.optional() })),
     z.lazy(() => z.object({ anchors: decoratedAnchorsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema, global: globalSchema.optional() })),
     z.lazy(() => z.object({ groups: decoratedGroupsSchema, global: globalSchema.optional() })),
     z.lazy(() => z.object({ pages: decoratedPagesSchema, global: globalSchema.optional() })),
 ]));

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

@@ -0,0 +1,6 @@
+import { GraphNode, HashedNodeMap, UUID, UUIDObjectHashMap } from './types/index.js';
+export declare const getObjectById: <T extends GraphNode>({ uuidObjectHashMap, hashedNodeMap, id, }: {
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+    id?: UUID;
+}) => T | undefined;

package/dist/openapi/v2/getObjectById.js

@@ -0,0 +1,5 @@
+export const getObjectById = ({ uuidObjectHashMap, hashedNodeMap, id, }) => {
+    if (!id || !uuidObjectHashMap[id])
+        return undefined;
+    return hashedNodeMap[uuidObjectHashMap[id]];
+};

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

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

package/dist/openapi/v2/mapDocument.js

@@ -0,0 +1,11 @@
+import hash from 'object-hash';
+export const mapDocument = ({ spec, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const documentNode = Object.assign(Object.assign(Object.assign(Object.assign({ openapi: spec.openapi, info: spec.info, servers: [], paths: [], webhooks: [], security: [] }, (spec.tags && { tags: spec.tags })), (spec.externalDocs && { externalDocs: spec.externalDocs })), (spec['x-express-openapi-additional-middleware'] && {
+        'x-express-openapi-additional-middleware': spec['x-express-openapi-additional-middleware'],
+    })), (spec['x-express-openapi-validation-strict'] && {
+        'x-express-openapi-validation-strict': spec['x-express-openapi-validation-strict'],
+    }));
+    const objectHash = hash(documentNode);
+    uuidObjectHashMap[uuid] = objectHash;
+    hashedNodeMap[objectHash] = documentNode;
+};

package/dist/openapi/v2/mapExample.js

@@ -10,7 +10,7 @@ export const mapExample = ({ example, refUuidMap, uuidObjectHashMap, hashedNodeM
         return;
     }
     // if ref, replace with uuid
-    if ('$ref' in example) {
+    if ('$ref' in example && example.$ref) {
         const refId = example.$ref;
         const refUuid = refUuidMap[refId] || uuidv4();
         example.$ref = refUuid;

package/dist/openapi/v2/mapHeader.js

@@ -9,7 +9,7 @@ export const mapHeader = ({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap
     // map uuid and hash to uuidObjectHashMap
     uuidObjectHashMap[uuid] = objectHash;
     // if ref, replace with uuid
-    if ('$ref' in header) {
+    if ('$ref' in header && header.$ref) {
         const refId = header.$ref;
         const refUuid = refUuidMap[refId] || uuidv4();
         header.$ref = refUuid;

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

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

package/dist/openapi/v2/mapOperation.js

@@ -0,0 +1,73 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapParameter } from './mapParameter.js';
+import { mapRequestBody } from './mapRequestBody.js';
+import { mapResponse } from './mapResponse.js';
+import { mapSecurityRequirement } from './mapSecurityRequirement.js';
+export const mapOperation = ({ operation, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    var _a;
+    const objectHash = hash(operation);
+    uuidObjectHashMap[uuid] = objectHash;
+    // parameters
+    if ('parameters' in operation) {
+        const parameterUuids = [];
+        (_a = operation.parameters) === null || _a === void 0 ? void 0 : _a.forEach((parameter) => {
+            const uuid = uuidv4();
+            mapParameter({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            parameterUuids.push(uuid);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        operation.parameters = parameterUuids;
+    }
+    // requestBody
+    if ('requestBody' in operation && operation.requestBody !== undefined) {
+        const uuid = uuidv4();
+        mapRequestBody({
+            requestBody: operation.requestBody,
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        operation.requestBody = uuid;
+    }
+    // responses
+    if ('responses' in operation && operation.responses) {
+        Object.entries(operation.responses).forEach(([statusCode, response]) => {
+            const uuid = uuidv4();
+            mapResponse({ response, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            if (operation.responses) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                operation.responses[statusCode] = uuid;
+            }
+        });
+    }
+    // callbacks (TODO: add support for callbacks)
+    // security
+    if ('security' in operation && operation.security) {
+        const securityUuids = [];
+        operation.security.forEach((security) => {
+            const uuid = uuidv4();
+            mapSecurityRequirement({ security, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            securityUuids.push(uuid);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        operation.security = securityUuids;
+    }
+    // servers
+    if ('servers' in operation && operation.servers) {
+        const serverUuids = [];
+        operation.servers.forEach((server) => {
+            const uuid = uuidv4();
+            const objectHash = hash(server);
+            uuidObjectHashMap[uuid] = objectHash;
+            hashedNodeMap[objectHash] = server;
+            serverUuids.push(uuid);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        operation.servers = serverUuids;
+    }
+    // add to hashedNodeMap
+    hashedNodeMap[objectHash] = operation;
+};

package/dist/openapi/v2/mapParameter.js

@@ -13,7 +13,7 @@ export const mapParameter = ({ parameter, refUuidMap, uuidObjectHashMap, hashedN
         return;
     }
     // if ref, replace with uuid
-    if ('$ref' in parameter) {
+    if ('$ref' in parameter && parameter.$ref) {
         const refId = parameter.$ref;
         const refUuid = refUuidMap[refId] || uuidv4();
         parameter.$ref = refUuid;

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

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

package/dist/openapi/v2/mapPath.js

@@ -0,0 +1,42 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { httpMethods } from '../types/endpoint.js';
+import { mapOperation } from './mapOperation.js';
+import { mapParameter } from './mapParameter.js';
+export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    var _a;
+    const objectHash = hash(pathItem);
+    uuidObjectHashMap[uuid] = objectHash;
+    if ('$ref' in pathItem && pathItem.$ref) {
+        const refId = pathItem.$ref;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        pathItem.$ref = refUuid;
+    }
+    // process path - Parameters
+    if ('parameters' in pathItem) {
+        const parameterUuids = [];
+        (_a = pathItem.parameters) === null || _a === void 0 ? void 0 : _a.forEach((parameter) => {
+            const uuid = uuidv4();
+            mapParameter({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            parameterUuids.push(uuid);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        pathItem.parameters = parameterUuids;
+    }
+    // process operations per http method
+    if (!('$ref' in pathItem)) {
+        httpMethods.forEach((method) => {
+            if (!(method in pathItem))
+                return;
+            const operation = pathItem[method];
+            if (!operation)
+                return;
+            const uuid = uuidv4();
+            mapOperation({ operation, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            pathItem[method] = uuid;
+        });
+    }
+    // store path object
+    hashedNodeMap[objectHash] = pathItem;
+};

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

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

package/dist/openapi/v2/mapPathComponents.js

@@ -0,0 +1,14 @@
+import { v4 as uuidv4 } from 'uuid';
+import { mapPath } from './mapPath.js';
+export const mapPathComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    if (!spec.components || !('pathItems' in spec.components))
+        return;
+    const pathComponents = spec.components.pathItems;
+    if (!pathComponents)
+        return;
+    Object.entries(pathComponents).forEach(([name, pathItem]) => {
+        const refId = `#/components/pathItems/${name}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        mapPath({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+    });
+};

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

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

package/dist/openapi/v2/mapPaths.js

@@ -0,0 +1,21 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getObjectById } from './getObjectById.js';
+import { mapPath } from './mapPath.js';
+export const mapPaths = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
+    const paths = spec.paths;
+    if (!paths)
+        return;
+    const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
+    if (!document)
+        return;
+    Object.entries(paths).forEach(([path, pathItem]) => {
+        if (!pathItem)
+            return;
+        // map to refUuidMap, uuidObjectHashMap, hashedNodeMap
+        const uuid = uuidv4();
+        refUuidMap[path] = uuid;
+        mapPath({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        // add path to document
+        document.paths.push(uuid);
+    });
+};

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

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

package/dist/openapi/v2/mapRequestBody.js

@@ -13,7 +13,7 @@ export const mapRequestBody = ({ requestBody, refUuidMap, uuidObjectHashMap, has
         return;
     }
     // if ref, replace with uuid
-    if ('$ref' in requestBody) {
+    if ('$ref' in requestBody && requestBody.$ref) {
         const refId = requestBody.$ref;
         const refUuid = refUuidMap[refId] || uuidv4();
         requestBody.$ref = refUuid;
@@ -23,6 +23,7 @@ export const mapRequestBody = ({ requestBody, refUuidMap, uuidObjectHashMap, has
         Object.entries(requestBody.content).forEach(([contentType, content]) => {
             const uuid = uuidv4();
             mapMedia({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             requestBody.content[contentType] = uuid;
         });
     }

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

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

package/dist/openapi/v2/mapResponse.js

@@ -0,0 +1,43 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { mapHeader } from './mapHeader.js';
+import { mapMedia } from './mapMedia.js';
+export const mapResponse = ({ response, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    // 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 && response.$ref) {
+        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) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                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) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                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/mapResponseComponents.js

@@ -1,7 +1,5 @@
-import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
-import { mapHeader } from './mapHeader.js';
-import { mapMedia } from './mapMedia.js';
+import { mapResponse } from './mapResponse.js';
 export const mapResponseComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
     var _a;
     const responseComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.responses;
@@ -12,40 +10,6 @@ export const mapResponseComponents = ({ spec, refUuidMap, uuidObjectHashMap, has
         // 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;
+        mapResponse({ response, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
     });
 };

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

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

package/dist/openapi/v2/mapSecurityRequirement.js

@@ -0,0 +1,19 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+export const mapSecurityRequirement = ({ security, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const securityRequirementObject = {};
+    Object.entries(security).forEach(([securitySchemeName, securitySchemeScopes]) => {
+        // create security requirement object
+        // add $ref to matching security scheme from components.securitySchemes
+        // add scopes to the security requirement object
+        const refId = `#/components/securitySchemes/${securitySchemeName}`;
+        const refUuid = refUuidMap[refId] || uuidv4();
+        securityRequirementObject[securitySchemeName] = {
+            $ref: refUuid,
+            scopes: securitySchemeScopes,
+        };
+    });
+    const objectHash = hash(securityRequirementObject);
+    uuidObjectHashMap[uuid] = objectHash;
+    hashedNodeMap[objectHash] = securityRequirementObject;
+};

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

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

package/dist/openapi/v2/mapSecurityRequirements.js

@@ -0,0 +1,30 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getObjectById } from './getObjectById.js';
+import { mapSecurityRequirement } from './mapSecurityRequirement.js';
+export const mapSecurityRequirements = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
+    const securityRequirements = spec.security;
+    if (!securityRequirements)
+        return;
+    const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
+    if (!document)
+        return;
+    // security requirements object = security: [{}, { 'A': [], 'B': [scopes], 'C': [scopes] }]
+    // refmap = { '#/components/securitySchemes/A': uuid1, '#/components/securitySchemes/B': uuid2, '#/components/securitySchemes/C': uuid3 }
+    // document.security = [uuid4, uuid5]
+    // uuidObjectHashMap = { uuid4: hash1, uuid5: hash2 }
+    // { hash1: {} }
+    // { hash2: { 'A': { $ref: uuid1, scopes: [] }, 'B': { $ref: uuid2, scopes: [scopes] }, 'C': { $ref: uuid3, scopes: [scopes] } } } }
+    securityRequirements.forEach((securityRequirement) => {
+        // create uuid for each global security requirement
+        const uuid = uuidv4();
+        mapSecurityRequirement({
+            security: securityRequirement,
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+        });
+        // associate security requirement object with document
+        document.security.push(uuid);
+    });
+};

package/dist/openapi/v2/mapSecuritySchemeComponents.js

@@ -10,7 +10,7 @@ export const mapSecuritySchemeComponents = ({ spec, refUuidMap, uuidObjectHashMa
         const uuid = refUuidMap[refId] || uuidv4();
         const objectHash = hash(securityScheme);
         uuidObjectHashMap[uuid] = objectHash;
-        if ('$ref' in securityScheme) {
+        if ('$ref' in securityScheme && securityScheme.$ref) {
             const refId = securityScheme.$ref;
             const refUuid = refUuidMap[refId] || uuidv4();
             securityScheme.$ref = refUuid;

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

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

package/dist/openapi/v2/mapServers.js

@@ -0,0 +1,18 @@
+import hash from 'object-hash';
+import { v4 as uuidv4 } from 'uuid';
+import { getObjectById } from './getObjectById.js';
+export const mapServers = ({ spec, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
+    const servers = spec.servers;
+    if (!servers)
+        return;
+    const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
+    if (!document)
+        return;
+    servers.forEach((server) => {
+        const uuid = uuidv4();
+        const objectHash = hash(server);
+        uuidObjectHashMap[uuid] = objectHash;
+        hashedNodeMap[objectHash] = server;
+        document.servers.push(uuid);
+    });
+};

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

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

package/dist/openapi/v2/mapWebhooks.js

@@ -0,0 +1,21 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getObjectById } from './getObjectById.js';
+import { mapPath } from './mapPath.js';
+export const mapWebhooks = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
+    if (!('webhooks' in spec))
+        return;
+    const webhooks = spec.webhooks;
+    if (!webhooks)
+        return;
+    const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
+    if (!document)
+        return;
+    Object.entries(webhooks).forEach(([webhookPath, webhook]) => {
+        if (!webhook)
+            return;
+        const uuid = uuidv4();
+        refUuidMap[webhookPath] = uuid;
+        mapPath({ pathItem: webhook, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        document.webhooks.push(uuid);
+    });
+};

package/dist/openapi/v2/openApiToSchemaGraph.js

@@ -1,17 +1,21 @@
+import { v4 as uuidv4 } from 'uuid';
 import { buildRefUuidMap } from './buildRefUuidMap.js';
+import { mapDocument } from './mapDocument.js';
 import { mapExampleComponents } from './mapExampleComponents.js';
 import { mapHeaderComponents } from './mapHeaderComponents.js';
 import { mapParameterComponents } from './mapParameterComponents.js';
+import { mapPathComponents } from './mapPathComponents.js';
+import { mapPaths } from './mapPaths.js';
 import { mapRequestBodyComponents } from './mapRequestBodyComponents.js';
 import { mapResponseComponents } from './mapResponseComponents.js';
 import { mapSchemaComponents } from './mapSchemaComponents.js';
+import { mapSecurityRequirements } from './mapSecurityRequirements.js';
 import { mapSecuritySchemeComponents } from './mapSecuritySchemeComponents.js';
+import { mapServers } from './mapServers.js';
+import { mapWebhooks } from './mapWebhooks.js';
 export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, }) => {
     // build map of component refs -> uuids
-    // eslint-disable-next-line unused-imports/no-unused-vars
     const refUuidMap = buildRefUuidMap(spec);
-    // eslint-disable-next-line unused-imports/no-unused-vars
-    const nodes = [];
     // build map of uuids -> object hashes
     const uuidObjectHashMap = {};
     // object hashes -> full objects
@@ -38,12 +42,20 @@ export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, })
     mapSecuritySchemeComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.links -> TODO (unsupported)
     // document.components.callbacks -> TODO (unsupported)
-    // document.components.pathItems -> TODO (unsupported)
+    // document.components.pathItems -> Path, possibly Parameter, Operation, RequestBody, Response, SecurityRequirement, Server
+    mapPathComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+    // document -> Document
+    const documentId = uuidv4();
+    mapDocument({ spec, uuidObjectHashMap, hashedNodeMap, uuid: documentId });
     // document.servers -> Server
+    mapServers({ spec, uuidObjectHashMap, hashedNodeMap, documentId });
+    // document.security -> SecurityRequirement
+    mapSecurityRequirements({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId });
+    // add paths and webhooks to ref-uuid map for fast lookup per page in client
     // document.paths -> Path, possibly Parameter, Operation, RequestBody, Response, SecurityRequirement, Server
+    mapPaths({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId });
     // document.webhooks -> Path, possibly Parameter, Operation, RequestBody, Response, SecurityRequirement, Server
-    // document.security -> SecurityRequirement
-    // document -> Document
+    mapWebhooks({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId });
     return {
         filename,
         originalFileLocation,