482 lines
13 KiB
Plaintext
482 lines
13 KiB
Plaintext
import { listOf, mapOf } from '.';
|
|
|
|
import type { NodeType } from '.';
|
|
import type { Oas2NodeType } from './redocly-yaml';
|
|
|
|
const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
|
|
|
|
const Root: NodeType = {
|
|
properties: {
|
|
swagger: { type: 'string' },
|
|
info: 'Info',
|
|
host: { type: 'string' },
|
|
basePath: { type: 'string' },
|
|
schemes: { type: 'array', items: { type: 'string' } },
|
|
consumes: { type: 'array', items: { type: 'string' } },
|
|
produces: { type: 'array', items: { type: 'string' } },
|
|
paths: 'Paths',
|
|
definitions: 'NamedSchemas',
|
|
parameters: 'NamedParameters',
|
|
responses: 'NamedResponses',
|
|
securityDefinitions: 'NamedSecuritySchemes',
|
|
security: 'SecurityRequirementList',
|
|
tags: 'TagList',
|
|
externalDocs: 'ExternalDocs',
|
|
'x-servers': 'XServerList',
|
|
'x-tagGroups': 'TagGroups',
|
|
'x-ignoredHeaderParameters': { type: 'array', items: { type: 'string' } },
|
|
},
|
|
required: ['swagger', 'paths', 'info'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Info: NodeType = {
|
|
properties: {
|
|
title: { type: 'string' },
|
|
description: { type: 'string' },
|
|
termsOfService: { type: 'string' },
|
|
contact: 'Contact',
|
|
license: 'License',
|
|
version: { type: 'string' },
|
|
'x-logo': 'Logo',
|
|
},
|
|
required: ['title', 'version'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Logo: NodeType = {
|
|
properties: {
|
|
url: { type: 'string' },
|
|
altText: { type: 'string' },
|
|
backgroundColor: { type: 'string' },
|
|
href: { type: 'string' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Contact: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
url: { type: 'string' },
|
|
email: { type: 'string' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const License: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
url: { type: 'string' },
|
|
},
|
|
required: ['name'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Paths: NodeType = {
|
|
properties: {},
|
|
additionalProperties: (_value: any, key: string) =>
|
|
key.startsWith('/') ? 'PathItem' : undefined,
|
|
};
|
|
|
|
const PathItem: NodeType = {
|
|
properties: {
|
|
$ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
|
|
parameters: 'ParameterList',
|
|
|
|
get: 'Operation',
|
|
put: 'Operation',
|
|
post: 'Operation',
|
|
delete: 'Operation',
|
|
options: 'Operation',
|
|
head: 'Operation',
|
|
patch: 'Operation',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Operation: NodeType = {
|
|
properties: {
|
|
tags: { type: 'array', items: { type: 'string' } },
|
|
summary: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalDocs: 'ExternalDocs',
|
|
operationId: { type: 'string' },
|
|
consumes: { type: 'array', items: { type: 'string' } },
|
|
produces: { type: 'array', items: { type: 'string' } },
|
|
parameters: 'ParameterList',
|
|
responses: 'Responses',
|
|
schemes: { type: 'array', items: { type: 'string' } },
|
|
deprecated: { type: 'boolean' },
|
|
security: 'SecurityRequirementList',
|
|
'x-codeSamples': 'XCodeSampleList',
|
|
'x-code-samples': 'XCodeSampleList', // deprecated
|
|
'x-hideTryItPanel': { type: 'boolean' },
|
|
},
|
|
required: ['responses'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const XCodeSample: NodeType = {
|
|
properties: {
|
|
lang: { type: 'string' },
|
|
label: { type: 'string' },
|
|
source: { type: 'string' },
|
|
},
|
|
};
|
|
|
|
const XServer: NodeType = {
|
|
properties: {
|
|
url: { type: 'string' },
|
|
description: { type: 'string' },
|
|
},
|
|
required: ['url'],
|
|
};
|
|
|
|
const ExternalDocs: NodeType = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
url: { type: 'string' },
|
|
},
|
|
required: ['url'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Parameter: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
in: { type: 'string', enum: ['query', 'header', 'path', 'formData', 'body'] },
|
|
description: { type: 'string' },
|
|
required: { type: 'boolean' },
|
|
schema: 'Schema',
|
|
type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array', 'file'] },
|
|
format: { type: 'string' },
|
|
allowEmptyValue: { type: 'boolean' },
|
|
items: 'ParameterItems',
|
|
collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
|
|
default: null,
|
|
maximum: { type: 'integer' },
|
|
exclusiveMaximum: { type: 'boolean' },
|
|
minimum: { type: 'integer' },
|
|
exclusiveMinimum: { type: 'boolean' },
|
|
maxLength: { type: 'integer' },
|
|
minLength: { type: 'integer' },
|
|
pattern: { type: 'string' },
|
|
maxItems: { type: 'integer' },
|
|
minItems: { type: 'integer' },
|
|
uniqueItems: { type: 'boolean' },
|
|
enum: { type: 'array' },
|
|
multipleOf: { type: 'number' },
|
|
'x-example': {}, // any
|
|
'x-examples': 'ExamplesMap',
|
|
},
|
|
required(value) {
|
|
if (!value || !value.in) {
|
|
return ['name', 'in'];
|
|
}
|
|
if (value.in === 'body') {
|
|
return ['name', 'in', 'schema'];
|
|
} else {
|
|
if (value.type === 'array') {
|
|
return ['name', 'in', 'type', 'items'];
|
|
} else {
|
|
return ['name', 'in', 'type'];
|
|
}
|
|
}
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const ParameterItems: NodeType = {
|
|
properties: {
|
|
type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array'] },
|
|
format: { type: 'string' },
|
|
items: 'ParameterItems',
|
|
collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
|
|
default: null,
|
|
maximum: { type: 'integer' },
|
|
exclusiveMaximum: { type: 'boolean' },
|
|
minimum: { type: 'integer' },
|
|
exclusiveMinimum: { type: 'boolean' },
|
|
maxLength: { type: 'integer' },
|
|
minLength: { type: 'integer' },
|
|
pattern: { type: 'string' },
|
|
maxItems: { type: 'integer' },
|
|
minItems: { type: 'integer' },
|
|
uniqueItems: { type: 'boolean' },
|
|
enum: { type: 'array' },
|
|
multipleOf: { type: 'number' },
|
|
},
|
|
required(value) {
|
|
if (value && value.type === 'array') {
|
|
return ['type', 'items'];
|
|
} else {
|
|
return ['type'];
|
|
}
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Responses: NodeType = {
|
|
properties: {
|
|
default: 'Response',
|
|
},
|
|
additionalProperties: (_v: any, key: string) =>
|
|
responseCodeRegexp.test(key) ? 'Response' : undefined,
|
|
};
|
|
|
|
const Response: NodeType = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
schema: 'Schema',
|
|
headers: mapOf('Header'),
|
|
examples: 'Examples',
|
|
'x-summary': { type: 'string' },
|
|
},
|
|
required: ['description'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Examples: NodeType = {
|
|
properties: {},
|
|
additionalProperties: { isExample: true },
|
|
};
|
|
|
|
const Header: NodeType = {
|
|
properties: {
|
|
description: { type: 'string' },
|
|
type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array'] },
|
|
format: { type: 'string' },
|
|
items: 'ParameterItems',
|
|
collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
|
|
default: null,
|
|
maximum: { type: 'integer' },
|
|
exclusiveMaximum: { type: 'boolean' },
|
|
minimum: { type: 'integer' },
|
|
exclusiveMinimum: { type: 'boolean' },
|
|
maxLength: { type: 'integer' },
|
|
minLength: { type: 'integer' },
|
|
pattern: { type: 'string' },
|
|
maxItems: { type: 'integer' },
|
|
minItems: { type: 'integer' },
|
|
uniqueItems: { type: 'boolean' },
|
|
enum: { type: 'array' },
|
|
multipleOf: { type: 'number' },
|
|
},
|
|
required(value) {
|
|
if (value && value.type === 'array') {
|
|
return ['type', 'items'];
|
|
} else {
|
|
return ['type'];
|
|
}
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const Tag: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalDocs: 'ExternalDocs',
|
|
'x-traitTag': { type: 'boolean' },
|
|
'x-displayName': { type: 'string' },
|
|
},
|
|
required: ['name'],
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const TagGroup: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
tags: { type: 'array', items: { type: 'string' } },
|
|
},
|
|
};
|
|
|
|
const Schema: NodeType = {
|
|
properties: {
|
|
format: { type: 'string' },
|
|
title: { type: 'string' },
|
|
description: { type: 'string' },
|
|
default: null,
|
|
multipleOf: { type: 'number' },
|
|
maximum: { type: 'number' },
|
|
minimum: { type: 'number' },
|
|
exclusiveMaximum: { type: 'boolean' },
|
|
exclusiveMinimum: { type: 'boolean' },
|
|
maxLength: { type: 'number' },
|
|
minLength: { type: 'number' },
|
|
pattern: { type: 'string' },
|
|
maxItems: { type: 'number' },
|
|
minItems: { type: 'number' },
|
|
uniqueItems: { type: 'boolean' },
|
|
maxProperties: { type: 'number' },
|
|
minProperties: { type: 'number' },
|
|
required: { type: 'array', items: { type: 'string' } },
|
|
enum: { type: 'array' },
|
|
type: {
|
|
type: 'string',
|
|
enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
|
|
},
|
|
items: (value: any) => {
|
|
if (Array.isArray(value)) {
|
|
return listOf('Schema');
|
|
} else {
|
|
return 'Schema';
|
|
}
|
|
},
|
|
allOf: listOf('Schema'),
|
|
properties: 'SchemaProperties',
|
|
additionalProperties: (value: any) => {
|
|
if (typeof value === 'boolean') {
|
|
return { type: 'boolean' };
|
|
} else {
|
|
return 'Schema';
|
|
}
|
|
},
|
|
discriminator: { type: 'string' },
|
|
readOnly: { type: 'boolean' },
|
|
xml: 'Xml',
|
|
externalDocs: 'ExternalDocs',
|
|
example: { isExample: true },
|
|
'x-tags': { type: 'array', items: { type: 'string' } },
|
|
'x-nullable': { type: 'boolean' },
|
|
'x-extendedDiscriminator': { type: 'string' },
|
|
'x-additionalPropertiesName': { type: 'string' },
|
|
'x-explicitMappingOnly': { type: 'boolean' },
|
|
'x-enumDescriptions': 'EnumDescriptions',
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const EnumDescriptions: NodeType = {
|
|
properties: {},
|
|
additionalProperties: { type: 'string' },
|
|
};
|
|
|
|
const SchemaProperties: NodeType = {
|
|
properties: {},
|
|
additionalProperties: 'Schema',
|
|
};
|
|
|
|
const Xml: NodeType = {
|
|
properties: {
|
|
name: { type: 'string' },
|
|
namespace: { type: 'string' },
|
|
prefix: { type: 'string' },
|
|
attribute: { type: 'boolean' },
|
|
wrapped: { type: 'boolean' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const SecurityScheme: NodeType = {
|
|
properties: {
|
|
type: { enum: ['basic', 'apiKey', 'oauth2'] },
|
|
description: { type: 'string' },
|
|
name: { type: 'string' },
|
|
in: { type: 'string', enum: ['query', 'header'] },
|
|
flow: { enum: ['implicit', 'password', 'application', 'accessCode'] },
|
|
authorizationUrl: { type: 'string' },
|
|
tokenUrl: { type: 'string' },
|
|
scopes: { type: 'object', additionalProperties: { type: 'string' } },
|
|
'x-defaultClientId': { type: 'string' },
|
|
},
|
|
required(value) {
|
|
switch (value?.type) {
|
|
case 'apiKey':
|
|
return ['type', 'name', 'in'];
|
|
case 'oauth2':
|
|
switch (value?.flow) {
|
|
case 'implicit':
|
|
return ['type', 'flow', 'authorizationUrl', 'scopes'];
|
|
case 'accessCode':
|
|
return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'scopes'];
|
|
case 'application':
|
|
case 'password':
|
|
return ['type', 'flow', 'tokenUrl', 'scopes'];
|
|
default:
|
|
return ['type', 'flow', 'scopes'];
|
|
}
|
|
default:
|
|
return ['type'];
|
|
}
|
|
},
|
|
allowed(value) {
|
|
switch (value?.type) {
|
|
case 'basic':
|
|
return ['type', 'description'];
|
|
case 'apiKey':
|
|
return ['type', 'name', 'in', 'description'];
|
|
case 'oauth2':
|
|
switch (value?.flow) {
|
|
case 'implicit':
|
|
return ['type', 'flow', 'authorizationUrl', 'description', 'scopes'];
|
|
case 'accessCode':
|
|
return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'description', 'scopes'];
|
|
case 'application':
|
|
case 'password':
|
|
return ['type', 'flow', 'tokenUrl', 'description', 'scopes'];
|
|
default:
|
|
return ['type', 'flow', 'tokenUrl', 'authorizationUrl', 'description', 'scopes'];
|
|
}
|
|
default:
|
|
return ['type', 'description'];
|
|
}
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
const SecurityRequirement: NodeType = {
|
|
properties: {},
|
|
additionalProperties: { type: 'array', items: { type: 'string' } },
|
|
};
|
|
|
|
const Example: NodeType = {
|
|
properties: {
|
|
value: { isExample: true },
|
|
summary: { type: 'string' },
|
|
description: { type: 'string' },
|
|
externalValue: { type: 'string' },
|
|
},
|
|
extensionsPrefix: 'x-',
|
|
};
|
|
|
|
export const Oas2Types: Record<Oas2NodeType, NodeType> = {
|
|
Root,
|
|
Tag,
|
|
TagList: listOf('Tag'),
|
|
TagGroups: listOf('TagGroup'),
|
|
TagGroup,
|
|
ExternalDocs,
|
|
Example,
|
|
ExamplesMap: mapOf('Example'),
|
|
EnumDescriptions,
|
|
SecurityRequirement,
|
|
SecurityRequirementList: listOf('SecurityRequirement'),
|
|
Info,
|
|
Contact,
|
|
License,
|
|
Logo,
|
|
Paths,
|
|
PathItem,
|
|
Parameter,
|
|
ParameterItems,
|
|
ParameterList: listOf('Parameter'),
|
|
Operation,
|
|
Examples,
|
|
Header,
|
|
Responses,
|
|
Response,
|
|
Schema,
|
|
Xml,
|
|
SchemaProperties,
|
|
NamedSchemas: mapOf('Schema'),
|
|
NamedResponses: mapOf('Response'),
|
|
NamedParameters: mapOf('Parameter'),
|
|
NamedSecuritySchemes: mapOf('SecurityScheme'),
|
|
SecurityScheme,
|
|
XCodeSample,
|
|
XCodeSampleList: listOf('XCodeSample'),
|
|
XServerList: listOf('XServer'),
|
|
XServer,
|
|
};
|