@mintlify/validation 0.1.493 → 0.1.495

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 && securityScheme.$ref) {
+            const refId = securityScheme.$ref;
+            const refUuid = refUuidMap[refId] || uuidv4();
+            securityScheme.$ref = refUuid;
+        }
+        hashedNodeMap[objectHash] = securityScheme;
+    });
+};

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,12 +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
@@ -22,18 +31,31 @@ export const openApiToSchemaGraph = ({ spec, filename, originalFileLocation, })
     // 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
+    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)
+    // 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,

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

@@ -5,7 +5,7 @@ export type HashId = string;
 export type RefUuidMap = Record<string, UUID>;
 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 GraphNode = SchemaOrRef | ResponseOrRef | HeaderOrRef | ParameterOrRef | Media | ExampleOrRef | RequestBodyOrRef | SecuritySchemeOrRef | Server | PathOrRef | Operation | SecurityRequirement | Document;
 export type SchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
 export type RefObject = OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
 export type SchemaOrRefObject = SchemaObject | RefObject;
@@ -19,10 +19,21 @@ export type SchemaOrRef = (SchemaOrRefObject & {
     anyOf?: UUID[];
     oneOf?: UUID[];
     not?: UUID;
+} & {
+    $ref?: never;
 }) | (RefObject & {
     $ref: UUID;
+} & {
+    items?: never;
+    properties?: never;
+    additionalProperties?: never;
+    allOf?: never;
+    anyOf?: never;
+    oneOf?: never;
+    not?: never;
 }) | HashId;
 export type ResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
+export type ResponseOrRefObject = ResponseObject | RefObject;
 export type ResponseOrRef = (ResponseObject & {
     headers?: {
         [header: string]: UUID;
@@ -33,8 +44,14 @@ export type ResponseOrRef = (ResponseObject & {
     links?: {
         [link: string]: UUID;
     };
+} & {
+    $ref?: never;
 }) | (RefObject & {
     $ref: UUID;
+} & {
+    headers?: never;
+    content?: never;
+    links?: never;
 });
 export type HeaderObject = OpenAPIV3.HeaderObject | OpenAPIV3_1.HeaderObject;
 export type HeaderOrRefObject = HeaderObject | RefObject;
@@ -46,8 +63,14 @@ export type HeaderOrRef = (HeaderObject & {
     content?: {
         [contentType: string]: UUID;
     };
+} & {
+    $ref?: never;
 }) | (RefObject & {
     $ref: UUID;
+} & {
+    schema?: never;
+    examples?: never;
+    content?: never;
 });
 export type ParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
 export type ParameterOrRefObject = ParameterObject | RefObject;
@@ -59,8 +82,14 @@ export type ParameterOrRef = (ParameterObject & {
     content?: {
         [contentType: string]: UUID;
     };
+} & {
+    $ref?: never;
 }) | (RefObject & {
     $ref: UUID;
+} & {
+    schema?: never;
+    examples?: never;
+    content?: never;
 });
 export type MediaObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
 export type Media = MediaObject & {
@@ -74,8 +103,12 @@ export type Media = MediaObject & {
 };
 export type ExampleObject = OpenAPIV3.ExampleObject | OpenAPIV3_1.ExampleObject;
 export type ExampleOrRefObject = ExampleObject | RefObject;
-export type ExampleOrRef = ExampleObject | (RefObject & {
+export type ExampleOrRef = (ExampleObject & {
+    $ref?: never;
+}) | (RefObject & {
     $ref: UUID;
+} & {
+    value?: never;
 });
 export type RequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
 export type RequestBodyOrRefObject = RequestBodyObject | RefObject;
@@ -83,20 +116,37 @@ export type RequestBodyOrRef = (RequestBodyObject & {
     content?: {
         [contentType: string]: UUID;
     };
+} & {
+    $ref?: never;
 }) | (RefObject & {
     $ref: UUID;
+} & {
+    content?: never;
 });
 export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject | OpenAPIV3_1.SecuritySchemeObject;
-export type SecurityScheme = SecuritySchemeObject;
+export type SecuritySchemeOrRefObject = SecuritySchemeObject | RefObject;
+export type SecuritySchemeOrRef = (SecuritySchemeObject & {
+    $ref?: never;
+}) | (RefObject & {
+    $ref: UUID;
+});
 export type ServerObject = OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject;
 export type Server = ServerObject;
 export type PathObject = OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject;
-export type Path = PathObject & {
-    pattern: string;
+export type PathObjectOrRef = PathObject | RefObject;
+export type PathOrRef = (PathObject & {
     parameters?: UUID[];
 } & {
     [method in OpenAPIV3.HttpMethods]: UUID;
-};
+} & {
+    $ref?: never;
+}) | (RefObject & {
+    $ref: UUID;
+} & {
+    parameters?: never;
+} & {
+    [method in OpenAPIV3.HttpMethods]: never;
+});
 export type OperationObject = OpenAPIV3.OperationObject | OpenAPIV3_1.OperationObject;
 export type OperationExtensions = {
     'x-mint'?: XMint;
@@ -119,11 +169,16 @@ export type Operation = OperationObject & {
     servers?: UUID[];
 } & OperationExtensions;
 export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject | OpenAPIV3_1.SecurityRequirementObject;
-export type SecurityRequirement = SecurityRequirementObject;
+export type SecurityRequirement = {
+    [name: string]: {
+        $ref?: UUID;
+        scopes?: string[];
+    };
+};
 export type DocumentObject = OpenAPIV3.Document | OpenAPIV3_1.Document;
-export type Document = DocumentObject & {
-    servers?: UUID[];
-    paths?: UUID[];
-    webhooks?: UUID[];
-    security?: UUID[];
+export type Document = Omit<DocumentObject, 'servers' | 'paths' | 'webhooks' | 'security'> & {
+    servers: UUID[];
+    paths: UUID[];
+    webhooks: UUID[];
+    security: UUID[];
 };