redoc/lib/utils/SchemaManager.js

192 lines
5.4 KiB
JavaScript
Raw Normal View History

'use strict';
import JsonSchemaRefParser from 'json-schema-ref-parser';
2015-10-09 10:50:02 +03:00
import JsonPointer from './JsonPointer';
import {methods as swaggerMethods} from './swagger-defs';
2015-10-27 20:44:08 +03:00
export default class SchemaManager {
constructor() {
if (SchemaManager.prototype._instance) {
return SchemaManager.prototype._instance;
}
SchemaManager.prototype._instance = this;
this._schema = {};
}
static instance() {
return new SchemaManager();
}
load(url) {
let promise = new Promise((resolve, reject) => {
this._schema = {};
JsonSchemaRefParser.bundle(url, {http: {withCredentials: false}})
.then(
(schema) => {
this._schema = schema;
resolve(this._schema);
2015-11-17 01:03:09 +03:00
this.init();
},
(err) => reject(err)
);
});
return promise;
}
2015-11-17 01:03:09 +03:00
/* calculate common used values */
init() {
if (!this._schema || !this._schema.schemes) return;
2015-11-17 02:14:55 +03:00
this.apiUrl = this._schema.schemes[0] + '://' + this._schema.host + this._schema.basePath;
2015-11-29 18:14:18 +03:00
if (this.apiUrl.endsWith('/')) {
this.apiUrl = this.apiUrl.substr(0, this.apiUrl.length - 1);
}
2015-11-17 01:03:09 +03:00
}
get schema() {
// TODO: consider returning promise
return this._schema;
}
2015-10-08 23:21:51 +03:00
byPointer(pointer) {
2015-10-10 16:01:41 +03:00
let res = null;
try {
2016-01-17 00:25:12 +03:00
// TODO: remove decodeURIComponent after this issue is fixed: https://github.com/BigstickCarpet/swagger-parser/issues/31
res = JsonPointer.get(this._schema, decodeURIComponent(pointer));
2015-10-10 16:01:41 +03:00
} catch(e) {/*skip*/ }
return res;
}
2015-10-08 23:21:51 +03:00
2015-10-25 14:26:38 +03:00
resolveRefs(obj) {
Object.keys(obj).forEach(key => {
if (obj[key].$ref) {
2015-12-12 18:29:50 +03:00
let resolved = this.byPointer(obj[key].$ref);
resolved._pointer = obj[key].$ref;
obj[key] = resolved;
2015-10-25 14:26:38 +03:00
}
});
return obj;
}
getMethodParams(methodPtr, resolveRefs) {
/* inject JsonPointer into array elements */
function injectPointers(array, root) {
2015-12-14 16:53:22 +03:00
if (!Array.isArray(array)) {
throw new Error(`parameters must be an array. Got ${typeof array} at ${root}`);
}
2015-10-25 14:26:38 +03:00
return array.map((element, idx) => {
element._pointer = JsonPointer.join(root, idx);
return element;
});
}
2015-12-12 18:29:50 +03:00
// accept pointer directly to parameters as well
if (JsonPointer.baseName(methodPtr) === 'parameters') {
methodPtr = JsonPointer.dirName(methodPtr);
2015-10-25 14:26:38 +03:00
}
2015-12-12 18:29:50 +03:00
//get path params
let pathParamsPtr = JsonPointer.join(JsonPointer.dirName(methodPtr), ['parameters']);
let pathParams = this.byPointer(pathParamsPtr) || [];
let methodParamsPtr = JsonPointer.join(methodPtr, ['parameters']);
let methodParams = this.byPointer(methodParamsPtr) || [];
pathParams = injectPointers(pathParams, pathParamsPtr);
methodParams = injectPointers(methodParams, methodParamsPtr);
2015-10-25 14:26:38 +03:00
if (resolveRefs) {
methodParams = this.resolveRefs(methodParams);
2015-11-04 23:39:46 +03:00
pathParams = this.resolveRefs(pathParams);
2015-10-25 14:26:38 +03:00
}
return methodParams.concat(pathParams);
}
2015-11-17 02:34:13 +03:00
getTagsMap() {
let tags = this._schema.tags || [];
var tagsMap = {};
for (let tag of tags) {
tagsMap[tag.name] = {
description: tag.description,
2015-12-12 14:49:22 +03:00
'x-traitTag': tag['x-traitTag'] || false
2015-11-17 02:34:13 +03:00
};
}
return tagsMap;
}
/* returns ES6 Map */
buildMenuTree() {
let tag2MethodMapping = new Map();
2015-11-04 23:39:05 +03:00
let definedTags = this._schema.tags || [];
// add tags into map to preserve order
for (let tag of definedTags) {
tag2MethodMapping.set(tag.name, {
'description': tag.description,
2015-12-01 01:29:01 +03:00
'x-traitTag': tag['x-traitTag'],
'methods': []
});
}
let paths = this._schema.paths;
for (let path of Object.keys(paths)) {
let methods = Object.keys(paths[path]).filter((k) => swaggerMethods.has(k));
for (let method of methods) {
let methodInfo = paths[path][method];
let tags = methodInfo.tags;
//TODO: mb need to do something cleverer
if (!tags || !tags.length) {
tags = ['[Other]'];
}
let methodPointer = JsonPointer.compile(['paths', path, method]);
let methodSummary = methodInfo.summary;
for (let tag of tags) {
let tagDetails = tag2MethodMapping.get(tag);
if (!tagDetails) {
tagDetails = {};
tag2MethodMapping.set(tag, tagDetails);
}
2015-12-01 01:29:01 +03:00
if (tagDetails['x-traitTag']) continue;
2015-10-30 12:48:36 +03:00
if (!tagDetails.methods) tagDetails.methods = [];
2016-02-07 17:10:32 +03:00
tagDetails.methods.push({
pointer: methodPointer,
summary: methodSummary,
operationId: methodInfo.operationId
});
}
}
}
return tag2MethodMapping;
}
2016-01-09 17:52:24 +03:00
findDerivedDefinitions(defPointer) {
let definition = this.byPointer(defPointer);
2016-01-15 23:42:55 +03:00
if (!definition) throw new Error(`Can't load schema at ${defPointer}`);
2016-01-09 17:52:24 +03:00
if (!definition.discriminator) return [];
let globalDefs = this._schema.definitions || {};
let res = [];
for (let defName of Object.keys(globalDefs)) {
if (!globalDefs[defName].allOf) continue;
let subTypes = globalDefs[defName].allOf;
let idx = subTypes.findIndex((subType) => {
if (subType.$ref === defPointer) return true;
return false;
});
if (idx < 0) continue;
2016-04-13 15:46:41 +03:00
let empty = false;
if (subTypes.length === 1) {
empty = true;
}
res.push({name: defName, $ref: `#/definitions/${defName}`, empty});
2016-01-09 17:52:24 +03:00
}
return res;
}
}