555 lines
16 KiB
Plaintext
555 lines
16 KiB
Plaintext
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Oas3Types = exports.Discriminator = exports.DiscriminatorMapping = exports.Xml = exports.ExternalDocs = void 0;
|
|
const _1 = require(".");
|
|
const ref_utils_1 = require("../ref-utils");
|
|
const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
|
|
const Root = {
|
|
properties: {
|
|
openapi: null,
|
|
info: 'Info',
|
|
servers: 'ServerList',
|
|
security: 'SecurityRequirementList',
|
|
tags: 'TagList',
|
|
externalDocs: 'ExternalDocs',
|
|
paths: 'Paths',
|
|
components: 'Components',
|
|
'x-webhooks': 'WebhooksMap',
|
|
'x-tagGroups': 'TagGroups',
|
|
'x-ignoredHeaderParameters': { type: 'array', items: { type: 'string' } },
|
|
},
|
|
required: ['openapi', 'paths', 'info'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Tag = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalDocs: 'ExternalDocs',
|
|
'x-traitTag': { type: 'boolean' },
|
|
'x-displayName': { type: 'string' },
|
|
},
|
|
required: ['name'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const TagGroup = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
tags: { type: 'array', items: { type: 'string' } },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
exports.ExternalDocs = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
url: { type: 'string' },
|
|
},
|
|
required: ['url'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Server = {
|
|
properties: {
|
|
url: { type: 'string' },
|
|
description: { type: 'string' },
|
|
variables: 'ServerVariablesMap',
|
|
},
|
|
required: ['url'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const ServerVariable = {
|
|
properties: {
|
|
enum: {
|
|
type: 'array',
|
|
items: { type: 'string' },
|
|
},
|
|
default: { type: 'string' },
|
|
description: { type: 'string' },
|
|
},
|
|
required: ['default'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const SecurityRequirement = {
|
|
properties: {},
|
|
additionalProperties: { type: 'array', items: { type: 'string' } },
|
|
};
|
|
const Info = {
|
|
properties: {
|
|
title: { type: 'string' },
|
|
version: { type: 'string' },
|
|
description: { type: 'string' },
|
|
termsOfService: { type: 'string' },
|
|
contact: 'Contact',
|
|
license: 'License',
|
|
'x-logo': 'Logo',
|
|
},
|
|
required: ['title', 'version'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Logo = {
|
|
properties: {
|
|
url: { type: 'string' },
|
|
altText: { type: 'string' },
|
|
backgroundColor: { type: 'string' },
|
|
href: { type: 'string' },
|
|
},
|
|
};
|
|
const Contact = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
url: { type: 'string' },
|
|
email: { type: 'string' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const License = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
url: { type: 'string' },
|
|
},
|
|
required: ['name'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Paths = {
|
|
properties: {},
|
|
additionalProperties: (_value, key) => key.startsWith('/') ? 'PathItem' : undefined,
|
|
};
|
|
const WebhooksMap = {
|
|
properties: {},
|
|
additionalProperties: () => 'PathItem',
|
|
};
|
|
const PathItem = {
|
|
properties: {
|
|
$ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
|
|
servers: 'ServerList',
|
|
parameters: 'ParameterList',
|
|
summary: { type: 'string' },
|
|
description: { type: 'string' },
|
|
get: 'Operation',
|
|
put: 'Operation',
|
|
post: 'Operation',
|
|
delete: 'Operation',
|
|
options: 'Operation',
|
|
head: 'Operation',
|
|
patch: 'Operation',
|
|
trace: 'Operation',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Parameter = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
in: { enum: ['query', 'header', 'path', 'cookie'] },
|
|
description: { type: 'string' },
|
|
required: { type: 'boolean' },
|
|
deprecated: { type: 'boolean' },
|
|
allowEmptyValue: { type: 'boolean' },
|
|
style: {
|
|
enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
|
|
},
|
|
explode: { type: 'boolean' },
|
|
allowReserved: { type: 'boolean' },
|
|
schema: 'Schema',
|
|
example: { isExample: true },
|
|
examples: 'ExamplesMap',
|
|
content: 'MediaTypesMap',
|
|
},
|
|
required: ['name', 'in'],
|
|
requiredOneOf: ['schema', 'content'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Operation = {
|
|
properties: {
|
|
tags: {
|
|
type: 'array',
|
|
items: { type: 'string' },
|
|
},
|
|
summary: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalDocs: 'ExternalDocs',
|
|
operationId: { type: 'string' },
|
|
parameters: 'ParameterList',
|
|
security: 'SecurityRequirementList',
|
|
servers: 'ServerList',
|
|
requestBody: 'RequestBody',
|
|
responses: 'Responses',
|
|
deprecated: { type: 'boolean' },
|
|
callbacks: 'CallbacksMap',
|
|
'x-codeSamples': 'XCodeSampleList',
|
|
'x-code-samples': 'XCodeSampleList', // deprecated
|
|
'x-hideTryItPanel': { type: 'boolean' },
|
|
},
|
|
required: ['responses'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const XCodeSample = {
|
|
properties: {
|
|
lang: { type: 'string' },
|
|
label: { type: 'string' },
|
|
source: { type: 'string' },
|
|
},
|
|
};
|
|
const RequestBody = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
required: { type: 'boolean' },
|
|
content: 'MediaTypesMap',
|
|
},
|
|
required: ['content'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const MediaTypesMap = {
|
|
properties: {},
|
|
additionalProperties: 'MediaType',
|
|
};
|
|
const MediaType = {
|
|
properties: {
|
|
schema: 'Schema',
|
|
example: { isExample: true },
|
|
examples: 'ExamplesMap',
|
|
encoding: 'EncodingMap',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Example = {
|
|
properties: {
|
|
value: { isExample: true },
|
|
summary: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalValue: { type: 'string' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Encoding = {
|
|
properties: {
|
|
contentType: { type: 'string' },
|
|
headers: 'HeadersMap',
|
|
style: {
|
|
enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
|
|
},
|
|
explode: { type: 'boolean' },
|
|
allowReserved: { type: 'boolean' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const EnumDescriptions = {
|
|
properties: {},
|
|
additionalProperties: { type: 'string' },
|
|
};
|
|
const Header = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
required: { type: 'boolean' },
|
|
deprecated: { type: 'boolean' },
|
|
allowEmptyValue: { type: 'boolean' },
|
|
style: {
|
|
enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
|
|
},
|
|
explode: { type: 'boolean' },
|
|
allowReserved: { type: 'boolean' },
|
|
schema: 'Schema',
|
|
example: { isExample: true },
|
|
examples: 'ExamplesMap',
|
|
content: 'MediaTypesMap',
|
|
},
|
|
requiredOneOf: ['schema', 'content'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Responses = {
|
|
properties: { default: 'Response' },
|
|
additionalProperties: (_v, key) => responseCodeRegexp.test(key) ? 'Response' : undefined,
|
|
};
|
|
const Response = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
headers: 'HeadersMap',
|
|
content: 'MediaTypesMap',
|
|
links: 'LinksMap',
|
|
'x-summary': { type: 'string' },
|
|
},
|
|
required: ['description'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Link = {
|
|
properties: {
|
|
operationRef: { type: 'string' },
|
|
operationId: { type: 'string' },
|
|
parameters: null, // TODO: figure out how to describe/validate this
|
|
requestBody: null, // TODO: figure out how to describe/validate this
|
|
description: { type: 'string' },
|
|
server: 'Server',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Schema = {
|
|
properties: {
|
|
externalDocs: 'ExternalDocs',
|
|
discriminator: 'Discriminator',
|
|
title: { type: 'string' },
|
|
multipleOf: { type: 'number', minimum: 0 },
|
|
maximum: { type: 'number' },
|
|
minimum: { type: 'number' },
|
|
exclusiveMaximum: { type: 'boolean' },
|
|
exclusiveMinimum: { type: 'boolean' },
|
|
maxLength: { type: 'integer', minimum: 0 },
|
|
minLength: { type: 'integer', minimum: 0 },
|
|
pattern: { type: 'string' },
|
|
maxItems: { type: 'integer', minimum: 0 },
|
|
minItems: { type: 'integer', minimum: 0 },
|
|
uniqueItems: { type: 'boolean' },
|
|
maxProperties: { type: 'integer', minimum: 0 },
|
|
minProperties: { type: 'integer', minimum: 0 },
|
|
required: { type: 'array', items: { type: 'string' } },
|
|
enum: { type: 'array' },
|
|
type: {
|
|
enum: ['object', 'array', 'string', 'number', 'integer', 'boolean'],
|
|
},
|
|
allOf: (0, _1.listOf)('Schema'),
|
|
anyOf: (0, _1.listOf)('Schema'),
|
|
oneOf: (0, _1.listOf)('Schema'),
|
|
not: 'Schema',
|
|
properties: 'SchemaProperties',
|
|
items: (value) => {
|
|
if (Array.isArray(value)) {
|
|
return (0, _1.listOf)('Schema');
|
|
}
|
|
else {
|
|
return 'Schema';
|
|
}
|
|
},
|
|
additionalProperties: (value) => {
|
|
if (typeof value === 'boolean') {
|
|
return { type: 'boolean' };
|
|
}
|
|
else {
|
|
return 'Schema';
|
|
}
|
|
},
|
|
description: { type: 'string' },
|
|
format: { type: 'string' },
|
|
default: null,
|
|
nullable: { type: 'boolean' },
|
|
readOnly: { type: 'boolean' },
|
|
writeOnly: { type: 'boolean' },
|
|
xml: 'Xml',
|
|
example: { isExample: true },
|
|
deprecated: { type: 'boolean' },
|
|
'x-tags': { type: 'array', items: { type: 'string' } },
|
|
'x-additionalPropertiesName': { type: 'string' },
|
|
'x-explicitMappingOnly': { type: 'boolean' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
exports.Xml = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
namespace: { type: 'string' },
|
|
prefix: { type: 'string' },
|
|
attribute: { type: 'boolean' },
|
|
wrapped: { type: 'boolean' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const SchemaProperties = {
|
|
properties: {},
|
|
additionalProperties: 'Schema',
|
|
};
|
|
exports.DiscriminatorMapping = {
|
|
properties: {},
|
|
additionalProperties: (value) => {
|
|
if ((0, ref_utils_1.isMappingRef)(value)) {
|
|
return { type: 'string', directResolveAs: 'Schema' };
|
|
}
|
|
else {
|
|
return { type: 'string' };
|
|
}
|
|
},
|
|
};
|
|
exports.Discriminator = {
|
|
properties: {
|
|
propertyName: { type: 'string' },
|
|
mapping: 'DiscriminatorMapping',
|
|
},
|
|
required: ['propertyName'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const Components = {
|
|
properties: {
|
|
parameters: 'NamedParameters',
|
|
schemas: 'NamedSchemas',
|
|
responses: 'NamedResponses',
|
|
examples: 'NamedExamples',
|
|
requestBodies: 'NamedRequestBodies',
|
|
headers: 'NamedHeaders',
|
|
securitySchemes: 'NamedSecuritySchemes',
|
|
links: 'NamedLinks',
|
|
callbacks: 'NamedCallbacks',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const ImplicitFlow = {
|
|
properties: {
|
|
refreshUrl: { type: 'string' },
|
|
scopes: { type: 'object', additionalProperties: { type: 'string' } }, // TODO: validate scopes
|
|
authorizationUrl: { type: 'string' },
|
|
},
|
|
required: ['authorizationUrl', 'scopes'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const PasswordFlow = {
|
|
properties: {
|
|
refreshUrl: { type: 'string' },
|
|
scopes: { type: 'object', additionalProperties: { type: 'string' } }, // TODO: validate scopes
|
|
tokenUrl: { type: 'string' },
|
|
},
|
|
required: ['tokenUrl', 'scopes'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const ClientCredentials = {
|
|
properties: {
|
|
refreshUrl: { type: 'string' },
|
|
scopes: { type: 'object', additionalProperties: { type: 'string' } }, // TODO: validate scopes
|
|
tokenUrl: { type: 'string' },
|
|
},
|
|
required: ['tokenUrl', 'scopes'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const AuthorizationCode = {
|
|
properties: {
|
|
refreshUrl: { type: 'string' },
|
|
authorizationUrl: { type: 'string' },
|
|
scopes: { type: 'object', additionalProperties: { type: 'string' } }, // TODO: validate scopes
|
|
tokenUrl: { type: 'string' },
|
|
'x-usePkce': (value) => {
|
|
if (typeof value === 'boolean') {
|
|
return { type: 'boolean' };
|
|
}
|
|
else {
|
|
return 'XUsePkce';
|
|
}
|
|
},
|
|
},
|
|
required: ['authorizationUrl', 'tokenUrl', 'scopes'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const OAuth2Flows = {
|
|
properties: {
|
|
implicit: 'ImplicitFlow',
|
|
password: 'PasswordFlow',
|
|
clientCredentials: 'ClientCredentials',
|
|
authorizationCode: 'AuthorizationCode',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const SecurityScheme = {
|
|
properties: {
|
|
type: { enum: ['apiKey', 'http', 'oauth2', 'openIdConnect'] },
|
|
description: { type: 'string' },
|
|
name: { type: 'string' },
|
|
in: { type: 'string', enum: ['query', 'header', 'cookie'] },
|
|
scheme: { type: 'string' },
|
|
bearerFormat: { type: 'string' },
|
|
flows: 'OAuth2Flows',
|
|
openIdConnectUrl: { type: 'string' },
|
|
'x-defaultClientId': { type: 'string' },
|
|
},
|
|
required(value) {
|
|
switch (value?.type) {
|
|
case 'apiKey':
|
|
return ['type', 'name', 'in'];
|
|
case 'http':
|
|
return ['type', 'scheme'];
|
|
case 'oauth2':
|
|
return ['type', 'flows'];
|
|
case 'openIdConnect':
|
|
return ['type', 'openIdConnectUrl'];
|
|
default:
|
|
return ['type'];
|
|
}
|
|
},
|
|
allowed(value) {
|
|
switch (value?.type) {
|
|
case 'apiKey':
|
|
return ['type', 'name', 'in', 'description'];
|
|
case 'http':
|
|
return ['type', 'scheme', 'bearerFormat', 'description'];
|
|
case 'oauth2':
|
|
return ['type', 'flows', 'description'];
|
|
case 'openIdConnect':
|
|
return ['type', 'openIdConnectUrl', 'description'];
|
|
default:
|
|
return ['type', 'description'];
|
|
}
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
const XUsePkce = {
|
|
properties: {
|
|
disableManualConfiguration: { type: 'boolean' },
|
|
hideClientSecretInput: { type: 'boolean' },
|
|
},
|
|
};
|
|
exports.Oas3Types = {
|
|
Root,
|
|
Tag,
|
|
TagList: (0, _1.listOf)('Tag'),
|
|
TagGroups: (0, _1.listOf)('TagGroup'),
|
|
TagGroup,
|
|
ExternalDocs: exports.ExternalDocs,
|
|
Server,
|
|
ServerList: (0, _1.listOf)('Server'),
|
|
ServerVariable,
|
|
ServerVariablesMap: (0, _1.mapOf)('ServerVariable'),
|
|
SecurityRequirement,
|
|
SecurityRequirementList: (0, _1.listOf)('SecurityRequirement'),
|
|
Info,
|
|
Contact,
|
|
License,
|
|
Paths,
|
|
PathItem,
|
|
Parameter,
|
|
ParameterList: (0, _1.listOf)('Parameter'),
|
|
Operation,
|
|
Callback: (0, _1.mapOf)('PathItem'),
|
|
CallbacksMap: (0, _1.mapOf)('Callback'),
|
|
RequestBody,
|
|
MediaTypesMap,
|
|
MediaType,
|
|
Example,
|
|
ExamplesMap: (0, _1.mapOf)('Example'),
|
|
Encoding,
|
|
EncodingMap: (0, _1.mapOf)('Encoding'),
|
|
EnumDescriptions,
|
|
Header,
|
|
HeadersMap: (0, _1.mapOf)('Header'),
|
|
Responses,
|
|
Response,
|
|
Link,
|
|
Logo,
|
|
Schema,
|
|
Xml: exports.Xml,
|
|
SchemaProperties,
|
|
DiscriminatorMapping: exports.DiscriminatorMapping,
|
|
Discriminator: exports.Discriminator,
|
|
Components,
|
|
LinksMap: (0, _1.mapOf)('Link'),
|
|
NamedSchemas: (0, _1.mapOf)('Schema'),
|
|
NamedResponses: (0, _1.mapOf)('Response'),
|
|
NamedParameters: (0, _1.mapOf)('Parameter'),
|
|
NamedExamples: (0, _1.mapOf)('Example'),
|
|
NamedRequestBodies: (0, _1.mapOf)('RequestBody'),
|
|
NamedHeaders: (0, _1.mapOf)('Header'),
|
|
NamedSecuritySchemes: (0, _1.mapOf)('SecurityScheme'),
|
|
NamedLinks: (0, _1.mapOf)('Link'),
|
|
NamedCallbacks: (0, _1.mapOf)('Callback'),
|
|
ImplicitFlow,
|
|
PasswordFlow,
|
|
ClientCredentials,
|
|
AuthorizationCode,
|
|
OAuth2Flows,
|
|
SecurityScheme,
|
|
XCodeSample,
|
|
XCodeSampleList: (0, _1.listOf)('XCodeSample'),
|
|
XUsePkce,
|
|
WebhooksMap,
|
|
};
|