@mintlify/validation 0.1.493 → 0.1.495

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/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.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/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/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.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 && parameter.$ref) {
+        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/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

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

package/dist/openapi/v2/mapRequestBody.js

@@ -0,0 +1,32 @@
+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 && requestBody.$ref) {
+        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 });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            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/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);
+    });
+};