@redocly/openapi-docs 3.12.0-rc.7 → 3.12.1

package/lib/models/mediaContent.js

@@ -1 +1,26 @@
-import{getMediaType as y}from"./mediaType.js";function c({parser:a,info:e,isRequestType:p,options:d,data:{operation:n,type:i,response:m,absolutePointer:s=""}}){const r=Object.keys(e).map(t=>y(a,t,p,e[t],d,{operation:n,type:i,response:m,absolutePointer:s})),o=r.filter(t=>!!t.examples||!!t.formExamples).length>0;return{mediaTypes:r,isRequestType:p,hasSample:o,operation:n}}function f(a,e){return e&&a.mediaTypes.find(d=>d.name===e)||a.mediaTypes[0]||{}}export{f as getActiveMediaType,c as getMediaContent};
+import { getMediaType } from './mediaType.js';
+/**
+ * MediaContent model ready to be sued by React components
+ * Contains multiple MediaTypes and keeps track of the currently active one
+ */
+export function getMediaContent({ parser, info, isRequestType, options, data: { operation, type, response, absolutePointer = '' }, }) {
+    const mediaTypes = Object.keys(info).map((name) => getMediaType(parser, name, isRequestType, info[name], options, {
+        operation,
+        type,
+        response,
+        absolutePointer,
+    }));
+    const hasSample = mediaTypes.filter((mime) => !!mime.examples || !!mime.formExamples).length > 0;
+    return {
+        mediaTypes,
+        isRequestType,
+        hasSample,
+        operation,
+    };
+}
+export function getActiveMediaType(content, activeMimeName) {
+    const mediaType = (activeMimeName && content.mediaTypes.find((type) => type.name === activeMimeName)) ||
+        content.mediaTypes[0];
+    return mediaType || {};
+}
+//# sourceMappingURL=mediaContent.js.map

package/lib/models/mediaType.js

@@ -1 +1,153 @@
-import{getSchema as E}from"./schema.js";import{isFormUrlEncoded as P,isJsonLike as b,isXmlLike as k,isMultipartFormData as j,JsonPointer as R,mapValues as w}from"../utils/index.js";import{getExamples as r}from"./example.js";import{safeSample as v}from"../services/code-samples/index.js";function g({parser:i,info:{encoding:e,schema:a},schema:l,mime:m,options:{isRequestType:s,onlyRequiredInSamples:u,generatedSamplesMaxDepth:p,format:d="json"}}){const f={skipReadOnly:s,skipWriteOnly:!s,skipNonRequired:s&&u,maxSampleDepth:p,quiet:!0,format:d};let n={};if(l&&l.oneOf)for(const o of l.oneOf){const t=v(o.rawSchema,f,i.definition);t!==null&&(l.discriminatorProp&&typeof t=="object"&&t&&t[l.discriminatorProp]&&(t[l.discriminatorProp]=o.title),n[o.title]=r({parser:i,infoOrRef:{value:t},mime:m,encoding:e}))}else if(l){const o=v(a,f,i.definition);o!==null?n={default:r({parser:i,infoOrRef:{value:o},mime:m,encoding:e})}:n={default:{value:null,rawValue:"null"}}}else n={default:{value:null,rawValue:"null"}};return n}function J(i,e,a,l,m,{operation:s,type:u,response:p,absolutePointer:d=""}){let f,n;const o=l.schema&&E({parser:i,schemaOrRef:l.schema,pointer:"",absolutePointer:R.join(d,["content",e,"schema"]),options:m,deps:{operation:s,type:u,response:p}}),{onlyRequiredInSamples:t,generatedSamplesMaxDepth:c}=m,{encoding:x,examples:O,example:S}=l;return m.unstable_skipSamples||(O!==void 0?f=w(O,h=>r({parser:i,infoOrRef:h,mime:e,encoding:x})):S!==void 0?f={default:r({parser:i,infoOrRef:{value:i.deref(S).resolved},mime:e,encoding:x})}:b(e)||k(e)?f=g({parser:i,info:l,schema:o,mime:e,options:{isRequestType:a,onlyRequiredInSamples:t,generatedSamplesMaxDepth:c,format:k(e)?"xml":"json"}}):(P(e)||j(e))&&(n=g({parser:i,info:l,schema:o,mime:e,options:{isRequestType:a,onlyRequiredInSamples:t,generatedSamplesMaxDepth:c}}))),{examples:f,schema:o,name:e,isRequestType:a,formExamples:n,onlyRequiredInSamples:t,operation:s}}export{J as getMediaType};
+import { getSchema } from './schema.js';
+import { isFormUrlEncoded, isJsonLike, isXmlLike, isMultipartFormData, JsonPointer, mapValues, } from '../utils/index.js';
+import { getExamples } from './example.js';
+import { safeSample } from '../services/code-samples/index.js';
+function generateExamples({ parser, info: { encoding, schema: infoSchema }, schema, mime, options: { isRequestType, onlyRequiredInSamples, generatedSamplesMaxDepth, format = 'json' }, }) {
+    // FIXME: check warning in rebilly spec
+    const samplerOptions = {
+        skipReadOnly: isRequestType,
+        skipWriteOnly: !isRequestType,
+        skipNonRequired: isRequestType && onlyRequiredInSamples,
+        maxSampleDepth: generatedSamplesMaxDepth,
+        quiet: true,
+        format,
+    };
+    let examples = {};
+    if (schema && schema.oneOf) {
+        for (const subSchema of schema.oneOf) {
+            const sample = safeSample(subSchema.rawSchema, samplerOptions, parser.definition);
+            if (sample === null) {
+                continue;
+            }
+            if (schema.discriminatorProp &&
+                typeof sample === 'object' &&
+                sample &&
+                sample[schema.discriminatorProp] // handle case with readOnly with discriminator
+            ) {
+                sample[schema.discriminatorProp] = subSchema.title;
+            }
+            examples[subSchema.title] = getExamples({
+                parser,
+                infoOrRef: {
+                    value: sample,
+                },
+                mime,
+                encoding,
+            });
+        }
+    }
+    else if (schema) {
+        const sample = safeSample(infoSchema, samplerOptions, parser.definition);
+        if (sample !== null) {
+            examples = {
+                default: getExamples({
+                    parser,
+                    infoOrRef: {
+                        value: sample,
+                    },
+                    mime,
+                    encoding,
+                }),
+            };
+        }
+        else {
+            examples = {
+                default: {
+                    value: null,
+                    rawValue: 'null',
+                },
+            };
+        }
+    }
+    else {
+        // default to {} example when schema is not defined
+        examples = {
+            default: {
+                value: null,
+                rawValue: 'null',
+            },
+        };
+    }
+    return examples;
+}
+/**
+ * @param parser
+ * @param name
+ * @param isRequestType needed to know if skip RO/RW fields in objects
+ * @param info
+ * @param options
+ * @param operation
+ * @param type
+ * @param response
+ */
+export function getMediaType(parser, name, isRequestType, info, options, { operation, type, response, absolutePointer = '', }) {
+    let examples;
+    let formExamples;
+    const schema = info.schema &&
+        getSchema({
+            parser,
+            schemaOrRef: info.schema,
+            pointer: '',
+            absolutePointer: JsonPointer.join(absolutePointer, ['content', name, 'schema']),
+            options,
+            deps: {
+                operation,
+                type,
+                response,
+            },
+        });
+    const { onlyRequiredInSamples, generatedSamplesMaxDepth } = options;
+    const { encoding, examples: infoExamples, example } = info;
+    if (!options.unstable_skipSamples) {
+        if (infoExamples !== undefined) {
+            examples = mapValues(infoExamples, (example) => getExamples({ parser, infoOrRef: example, mime: name, encoding }));
+        }
+        else if (example !== undefined) {
+            examples = {
+                default: getExamples({
+                    parser,
+                    infoOrRef: { value: parser.deref(example).resolved },
+                    mime: name,
+                    encoding,
+                }),
+            };
+        }
+        else if (isJsonLike(name) || isXmlLike(name)) {
+            examples = generateExamples({
+                parser,
+                info,
+                schema,
+                mime: name,
+                options: {
+                    isRequestType,
+                    onlyRequiredInSamples,
+                    generatedSamplesMaxDepth,
+                    format: isXmlLike(name) ? 'xml' : 'json',
+                },
+            });
+        }
+        else if (isFormUrlEncoded(name) || isMultipartFormData(name)) {
+            formExamples = generateExamples({
+                parser,
+                info,
+                schema,
+                mime: name,
+                options: {
+                    isRequestType,
+                    onlyRequiredInSamples,
+                    generatedSamplesMaxDepth,
+                },
+            });
+        }
+    }
+    return {
+        examples,
+        schema,
+        name,
+        isRequestType,
+        formExamples,
+        onlyRequiredInSamples,
+        operation,
+    };
+}
+//# sourceMappingURL=mediaType.js.map

package/lib/models/operation.js

@@ -1 +1,166 @@
-import{REDOCLY_TEAMS_RBAC as y}from"@redocly/config";import{removeLeadingSlash as b}from"@redocly/theme/core/openapi";import{configure as v}from"@redocly/theme/ext/configure";import{extractExtensions as x,getOperationId as R,getOperationName as q,getStatusCodeType as P,getValueFromMdParsedExtension as B,isStatusCode as E,JsonPointer as C,mergeParams as k,normalizeServers as o,sortByDeprecated as V,sortByRequired as I,updateOperationWithRequestValues as O,updateParametersWithUserValues as N}from"../utils/index.js";import{getCallback as W}from"./callback.js";import{getField as w}from"./field.js";import{getRequestBody as A}from"./request.js";import{getSecurity as S}from"./security.js";import{getResponse as F}from"./response.js";import{getHref as M}from"../services/menu/operation.js";function Z(s){return s.lang==="Payload"&&"requestBodyContent"in s}function $(s,e,t,a,m,d,c){const h=e.isWebhook,r={operationDefinition:e,parent:t,pointer:e.pointer,description:B(e,"description"),externalDocs:e.externalDocs,deprecated:!!e.deprecated,httpVerb:e.httpVerb,operationId:e.operationId,path:e.pathName,isWebhook:h,isCallback:!!d?.isCallback,isEvent:d?.isCallback||h,name:q(e),defaultExampleName:e.defaultSampleName,[y]:e[y]||t?.[y],type:"operation",callbackId:d?.id,href:m,get callbacks(){return Object.keys(e.callbacks||[]).map(u=>W(s,u,e.callbacks?.[u],r.pointer,a,m,t,c))},get responses(){let u=!1;return Object.keys(e.responses||[]).filter(l=>l==="default"?!0:(P(l)==="success"&&(u=!0),E(l))).map(l=>F({parser:s,code:l,defaultAsError:u,infoOrRef:e.responses[l],options:a,isEvent:r.isEvent,operation:r}))},get parameters(){return j(s,e,r,a,g)}};if(d?.isCallback)r.security=S(e.security,s),r.servers=o("",e.servers||e.pathServers||[]),r.id=b(m);else{r.id=R(e,t),r.href=r.href||M(r),r.security=S(e.security||s.definition.security,s);const u=e.servers||(e.pathServers?.length?e.pathServers:null)||s.definition.servers||[];r.servers=o(s.definitionUrl,L(u,a.mockServer))}a.showExtensions&&(r.extensions=x(e,a.showExtensions)),r.requestBody=e.requestBody?A({parser:s,infoOrRef:e.requestBody,options:a,operation:r,isEvent:r.isEvent}):void 0;const p=r.requestBody?.content;r.payload={lang:"Payload",source:"",requestBodyContent:p?.hasSample?p:void 0},r.definitionSamples=e["x-codeSamples"]||[],r.badges=e["x-badges"]?.map(({name:u,color:l,position:n})=>({name:u,color:l||"var(--color-info-base)",position:n||"after"}))||[],r.hasSamples=p?.hasSample||r.definitionSamples.length>0,r.hideReplay=e["x-hideReplay"]===!0;const f={userClaims:c,operation:{operationId:r.operationId,name:r.name,path:r.path,href:r.href,method:r.httpVerb},servers:r.servers},g=(v(f)||{}).requestValues||{};return O(r,g),r}function j(s,e,t,a,m){let d=k(s,e.pathParameters,e.parameters,{pathPointer:C.dirName(t.pointer),operationPointer:t.pointer}).map(({paramOrRef:c,pointer:h})=>{const r=w(s,c,h,a,{operation:t,type:"request"});return N(r,m),r});return a.sortRequiredPropsFirst&&(d=I(d)),V(d)}function L(s,e){if(!e)return s;const t={url:e.url,description:e.description};switch(e.position){case"first":return[t,...s];case"last":return[...s,t];case"replace":return[t];default:return s}}export{$ as getOperation,Z as isPayloadSample,L as mergeInMockServer};
+import { REDOCLY_TEAMS_RBAC } from '@redocly/config';
+import { removeLeadingSlash } from '@redocly/theme/core/openapi';
+import { configure } from '@redocly/theme/ext/configure';
+import { extractExtensions, getOperationId, getOperationName, getStatusCodeType, getValueFromMdParsedExtension, isStatusCode, JsonPointer, mergeParams, normalizeServers, sortByDeprecated, sortByRequired, updateOperationWithRequestValues, updateParametersWithUserValues, } from '../utils/index.js';
+import { getCallback } from './callback.js';
+import { getField } from './field.js';
+import { getRequestBody } from './request.js';
+import { getSecurity } from './security.js';
+import { getResponse } from './response.js';
+import { getHref } from '../services/menu/operation.js';
+export function isPayloadSample(sample) {
+    return sample.lang === 'Payload' && 'requestBodyContent' in sample;
+}
+export function getOperation(parser, operationDefinition, parent, options, href, callback, userClaims) {
+    const isWebhook = operationDefinition.isWebhook;
+    const operation = {
+        operationDefinition,
+        parent,
+        pointer: operationDefinition.pointer,
+        description: getValueFromMdParsedExtension(operationDefinition, 'description'),
+        externalDocs: operationDefinition.externalDocs,
+        deprecated: !!operationDefinition.deprecated,
+        httpVerb: operationDefinition.httpVerb,
+        operationId: operationDefinition.operationId,
+        path: operationDefinition.pathName,
+        isWebhook,
+        isCallback: Boolean(callback?.isCallback),
+        isEvent: callback?.isCallback || isWebhook,
+        name: getOperationName(operationDefinition),
+        defaultExampleName: operationDefinition.defaultSampleName,
+        [REDOCLY_TEAMS_RBAC]: operationDefinition[REDOCLY_TEAMS_RBAC] || parent?.[REDOCLY_TEAMS_RBAC],
+        type: 'operation',
+        callbackId: callback?.id,
+        href,
+        get callbacks() {
+            return Object.keys(operationDefinition.callbacks || []).map((callbackEventName) => {
+                return getCallback(parser, callbackEventName, operationDefinition.callbacks?.[callbackEventName], operation.pointer, options, href, parent, userClaims);
+            });
+        },
+        get responses() {
+            let hasSuccessResponses = false;
+            return Object.keys(operationDefinition.responses || [])
+                .filter((code) => {
+                if (code === 'default') {
+                    return true;
+                }
+                if (getStatusCodeType(code) === 'success') {
+                    hasSuccessResponses = true;
+                }
+                return isStatusCode(code);
+            }) // filter out other props (e.g. x-props)
+                .map((code) => {
+                return getResponse({
+                    parser,
+                    code,
+                    defaultAsError: hasSuccessResponses,
+                    infoOrRef: operationDefinition.responses[code],
+                    options,
+                    isEvent: operation.isEvent,
+                    operation,
+                });
+            });
+        },
+        get parameters() {
+            return processParameters(parser, operationDefinition, operation, options, userDefinedRequestValues);
+        },
+    };
+    if (callback?.isCallback) {
+        // NOTE: Callbacks by default should not inherit the specification's global `security` definition.
+        // Can be defined individually per-callback in the specification. Defaults to none.
+        operation.security = getSecurity(operationDefinition.security, parser);
+        // TODO: update getting pathInfo for overriding servers on path level
+        operation.servers = normalizeServers('', operationDefinition.servers || operationDefinition.pathServers || []);
+        // TODO: remove it when all deep links are updated with one proper handler
+        operation.id = removeLeadingSlash(href); // pass operation href as id for callbacks
+    }
+    else {
+        operation.id = getOperationId(operationDefinition, parent);
+        operation.href = operation.href || getHref(operation);
+        operation.security = getSecurity(operationDefinition.security || parser.definition.security, parser);
+        const servers = operationDefinition.servers ||
+            (operationDefinition.pathServers?.length ? operationDefinition.pathServers : null) ||
+            parser.definition.servers ||
+            [];
+        operation.servers = normalizeServers(parser.definitionUrl, mergeInMockServer(servers, options.mockServer));
+    }
+    if (options.showExtensions) {
+        operation.extensions = extractExtensions(operationDefinition, options.showExtensions);
+    }
+    operation.requestBody = operationDefinition.requestBody
+        ? getRequestBody({
+            parser: parser,
+            infoOrRef: operationDefinition.requestBody,
+            options,
+            operation,
+            isEvent: operation.isEvent,
+        })
+        : undefined;
+    const requestBodyContent = operation.requestBody?.content;
+    operation.payload = {
+        lang: 'Payload',
+        source: '',
+        requestBodyContent: requestBodyContent?.hasSample ? requestBodyContent : undefined,
+    };
+    operation.definitionSamples = operationDefinition['x-codeSamples'] || [];
+    operation.badges =
+        operationDefinition['x-badges']?.map(({ name, color, position }) => ({
+            name,
+            color: color || 'var(--color-info-base)',
+            position: position || 'after',
+        })) || [];
+    operation.hasSamples = requestBodyContent?.hasSample || operation.definitionSamples.length > 0;
+    operation.hideReplay = operationDefinition['x-hideReplay'] === true;
+    const operationParams = {
+        userClaims,
+        operation: {
+            operationId: operation.operationId,
+            name: operation.name,
+            path: operation.path,
+            href: operation.href,
+            method: operation.httpVerb,
+        },
+        servers: operation.servers,
+    };
+    const configResult = configure(operationParams) || {};
+    const userDefinedRequestValues = configResult.requestValues || {};
+    updateOperationWithRequestValues(operation, userDefinedRequestValues);
+    return operation;
+}
+function processParameters(parser, operationDefinition, operation, options, userDefinedRequestValues) {
+    let parameters = mergeParams(parser, operationDefinition.pathParameters, operationDefinition.parameters, {
+        pathPointer: JsonPointer.dirName(operation.pointer),
+        operationPointer: operation.pointer,
+    }).map(({ paramOrRef, pointer }) => {
+        const param = getField(parser, paramOrRef, pointer, options, {
+            operation,
+            type: 'request',
+        });
+        updateParametersWithUserValues(param, userDefinedRequestValues);
+        return param;
+    });
+    if (options.sortRequiredPropsFirst) {
+        parameters = sortByRequired(parameters);
+    }
+    return sortByDeprecated(parameters);
+}
+export function mergeInMockServer(servers, mockServerOptions) {
+    if (!mockServerOptions) {
+        return servers;
+    }
+    const mockServer = {
+        url: mockServerOptions.url,
+        description: mockServerOptions.description,
+    };
+    switch (mockServerOptions.position) {
+        case 'first':
+            return [mockServer, ...servers];
+        case 'last':
+            return [...servers, mockServer];
+        case 'replace':
+            return [mockServer];
+        default:
+            return servers;
+    }
+}
+//# sourceMappingURL=operation.js.map

package/lib/models/request.js

@@ -1 +1,25 @@
-import{getContentWithLegacyExamples as f,getValueFromMdParsedExtension as m,JsonPointer as p}from"../utils/index.js";import{getMediaContent as q}from"./mediaContent.js";function y({parser:t,infoOrRef:n,options:s,isEvent:d,operation:o}){const{resolved:e}=t.deref(n),u=m(e,"description")||"",c=e.required;let i;const a=!d,r=f(e);return r!==void 0&&(i=q({parser:t,info:r,isRequestType:a,options:s,data:{operation:o,type:"request",absolutePointer:n.$ref||p.join(o.pointer,["requestBody"])}})),{description:u,required:c,content:i}}export{y as getRequestBody};
+import { getContentWithLegacyExamples, getValueFromMdParsedExtension, JsonPointer, } from '../utils/index.js';
+import { getMediaContent } from './mediaContent.js';
+export function getRequestBody({ parser, infoOrRef, options, isEvent, operation, }) {
+    const { resolved: info } = parser.deref(infoOrRef);
+    const description = getValueFromMdParsedExtension(info, 'description') || '';
+    const required = info.required;
+    let content;
+    const isRequestType = !isEvent;
+    const mediaContent = getContentWithLegacyExamples(info);
+    if (mediaContent !== undefined) {
+        content = getMediaContent({
+            parser,
+            info: mediaContent,
+            isRequestType,
+            options,
+            data: {
+                operation,
+                type: 'request',
+                absolutePointer: infoOrRef['$ref'] || JsonPointer.join(operation.pointer, ['requestBody']),
+            },
+        });
+    }
+    return { description, required, content };
+}
+//# sourceMappingURL=request.js.map

package/lib/models/response.js

@@ -1 +1,46 @@
-import{getStatusCodeType as h,getContentWithLegacyExamples as x,JsonPointer as c,getValueFromMdParsedExtension as d}from"../utils/index.js";import{getField as C}from"./field.js";import{getMediaContent as j}from"./mediaContent.js";function F({parser:n,code:s,defaultAsError:f,infoOrRef:m,options:p,isEvent:y,operation:o}){const g=!!y,{resolved:t}=n.deref(m),e={code:s};t["x-summary"]!==void 0?(e.summary=d(t,"x-summary"),e.description=d(t,"description")||""):(e.summary=d(t,"description")||"",e.description=""),e.type=h(s,f);const r=t.headers,a=m.$ref||c.join(o?.pointer||"",["responses",s]);r!==void 0&&(e.headers=Object.keys(r).map(i=>{const l=r[i];return C(n,{...l,name:i},c.join(a,["headers",i]),p,{operation:o,type:"response",response:e})}));const u=x(t);return u!==void 0&&(e.content=j({parser:n,info:u,isRequestType:g,options:p,data:{operation:o,type:"response",response:e,absolutePointer:a}})),e}export{F as getResponse};
+import { getStatusCodeType, getContentWithLegacyExamples, JsonPointer, getValueFromMdParsedExtension, } from '../utils/index.js';
+import { getField } from './field.js';
+import { getMediaContent } from './mediaContent.js';
+export function getResponse({ parser, code, defaultAsError, infoOrRef, options, isEvent, operation, }) {
+    const isRequestType = !!isEvent;
+    const { resolved: info } = parser.deref(infoOrRef);
+    const response = { code };
+    if (info['x-summary'] !== undefined) {
+        response.summary = getValueFromMdParsedExtension(info, 'x-summary');
+        response.description = getValueFromMdParsedExtension(info, 'description') || '';
+    }
+    else {
+        response.summary = getValueFromMdParsedExtension(info, 'description') || '';
+        response.description = '';
+    }
+    response.type = getStatusCodeType(code, defaultAsError);
+    const infoHeaders = info.headers;
+    const absolutePointer = infoOrRef['$ref'] || JsonPointer.join(operation?.pointer || '', ['responses', code]);
+    if (infoHeaders !== undefined) {
+        response.headers = Object.keys(infoHeaders).map((name) => {
+            const header = infoHeaders[name];
+            return getField(parser, { ...header, name }, JsonPointer.join(absolutePointer, ['headers', name]), options, {
+                operation,
+                type: 'response',
+                response,
+            });
+        });
+    }
+    const mediaContent = getContentWithLegacyExamples(info);
+    if (mediaContent !== undefined) {
+        response.content = getMediaContent({
+            parser,
+            info: mediaContent,
+            isRequestType,
+            options,
+            data: {
+                operation,
+                type: 'response',
+                response,
+                absolutePointer,
+            },
+        });
+    }
+    return response;
+}
+//# sourceMappingURL=response.js.map