swaggerValidate = function (swaggerJson) {
/*
* this function will validate the json-object swaggerJson
*/
var operation;
var operationIdDict;
var pathDict;
var prefix;
var test;
var tmp;
operationIdDict = {};
swaggerJson = swaggerJson || {};
local.swaggerValidateDataSchema({
data: swaggerJson,
modeSchema: true,
prefix: ["swaggerJson"],
schema: local.swaggerSchemaJson,
swaggerJson: swaggerJson
});
pathDict = {};
Object.keys(swaggerJson.paths).forEach(function (path) {
prefix = ["swaggerJson", "paths", path];
// validate semanticPaths1
test = path.indexOf("?") < 0;
local.throwSwaggerError(!test && {
errorType: "semanticPaths1",
prefix: prefix
});
tmp = path.replace((
/\{.*?\}/g
), "{}");
// validate semanticPaths2
test = !pathDict[tmp];
local.throwSwaggerError(!test && {
errorType: "semanticPaths2",
pathList: [pathDict[tmp], path],
prefix: prefix
});
pathDict[tmp] = path;
// validate semanticPaths3
tmp = {};
path.replace((
/\{.*?\}/g
), function (match0) {
test = !tmp[match0];
local.throwSwaggerError(!test && {
errorType: "semanticPaths3",
name: match0,
prefix: prefix
});
tmp[match0] = true;
});
// validate semanticPaths5
test = path.indexOf("{}") < 0;
local.throwSwaggerError(!test && {
errorType: "semanticPaths5",
prefix: prefix
});
});
// validate swaggerJson.definitions[key].properties[ii].default
Object.keys(swaggerJson.definitions || {}).forEach(function (schemaName) {
tmp = local.swaggerValidateDataSchema({
// dereference definition
modeDereference: true,
prefix: ["swaggerJson", "definitions", schemaName],
schema: swaggerJson.definitions[schemaName],
swaggerJson: swaggerJson
});
Object.keys(tmp.properties || {}).forEach(function (key) {
local.swaggerValidateDataSchema({
modeDefault: true,
prefix: ["swaggerJson", "definitions", schemaName, "properties", key],
schema: tmp.properties[key],
swaggerJson: swaggerJson
});
});
});
// validate swaggerJson.parameters[key].default
Object.keys(swaggerJson.parameters || []).forEach(function (key) {
local.swaggerValidateDataSchema({
modeDefault: true,
prefix: ["swaggerJson", "parameters", key],
schema: swaggerJson.parameters[key],
swaggerJson: swaggerJson
});
});
// validate swaggerJson.paths[key][key].parameters[ii].default
Object.keys(swaggerJson.paths).forEach(function (path) {
Object.keys(swaggerJson.paths[path]).forEach(function (method) {
prefix = ["swaggerJson", "paths", path, method];
operation = local.swaggerValidateDataSchema({
// dereference operation
modeDereference: true,
prefix: prefix,
schema: swaggerJson.paths[path][method],
swaggerJson: swaggerJson
});
// validate semanticOperationIds1
test = !operationIdDict[operation.operationId];
local.throwSwaggerError(!test && {
data: operation.operationId,
errorType: "semanticOperationIds1",
prefix: prefix.concat(["operationId"])
});
operationIdDict[operation.operationId]...n/a
swaggerValidateDataParameters = function (option) {
/*
* this function will validate the items in option.paramDict
* against the schemaP's in option.parameters
*/
var errorList;
errorList = [];
option.parameters.forEach(function (schemaP) {
local.tryCatchOnError(function () {
local.swaggerValidateDataSchema({
data: option.data[schemaP.name],
dataReadonlyRemove: [
option.dataReadonlyRemove || {},
schemaP.name,
option.dataReadonlyRemove && option.dataReadonlyRemove[schemaP.name]
],
prefix: option.prefix.concat([schemaP.name]),
schema: schemaP,
swaggerJson: local.swaggerJson
});
}, function (errorCaught) {
console.error(errorCaught.message);
errorList.push(errorCaught);
errorCaught.errorList = errorList;
});
});
return errorList;
}n/a
swaggerValidateDataSchema = function (option) {
/*
* this function will validate option.data against the swagger option.schema
* http://json-schema.org/draft-04/json-schema-validation.html#rfc.section.5
*/
var $ref;
var circularSet;
var data;
var dataReadonlyRemove2;
var ii;
var list;
var oneOf;
var schema;
var test;
var tmp;
if (!option.schema) {
return;
}
data = option.data;
option.dataReadonlyRemove = option.dataReadonlyRemove || [{}, "", null];
dataReadonlyRemove2 = option.dataReadonlyRemove[2] || {};
schema = option.schema;
circularSet = new Set();
while (true) {
// dereference schema.schema
while (schema.schema) {
schema = schema.schema;
}
// dereference schema.oneOf
oneOf = (data && schema.oneOf) || [];
ii = 0;
while (ii < oneOf.length) {
tmp = String(oneOf[ii] && oneOf[ii].$ref)
.replace("http://json-schema.org/draft-04/schema#", "#");
switch (tmp + " " + (!local.isNullOrUndefined(data.$ref) || data.in)) {
case "#/definitions/bodyParameter body":
case "#/definitions/formDataParameterSubSchema formData":
case "#/definitions/headerParameterSubSchema header":
case "#/definitions/jsonReference true":
case "#/definitions/pathParameterSubSchema path":
case "#/definitions/queryParameterSubSchema query":
schema = local.swaggerSchemaJson.definitions[tmp.split("/")[2]];
break;
default:
switch (tmp) {
case "#/definitions/bodyParameter":
case "#/definitions/jsonReference":
schema = oneOf[ii ^ 1];
break;
}
}
if (!schema.oneOf) {
break;
}
ii += 1;
}
// dereference schema.$ref
$ref = schema && schema.$ref;
if (!$ref) {
break;
}
test = !circularSet.has($ref);
local.throwSwaggerError(!test && {
data: data,
errorType: "schemaDereferenceCircular",
prefix: option.prefix,
schema: schema
});
circularSet.add($ref);
// validate semanticWalker6
test = (
$ref.indexOf("#/") === 0
|| $ref.indexOf("http://json-schema.org/draft-04/schema#/") === 0
);
local.throwSwaggerError(!test && {
data: $ref,
errorType: "semanticWalker6",
prefix: option.prefix.concat(["$ref"])
});
switch (option.modeSchema && $ref) {
case "http://json-schema.org/draft-04/schema#/definitions/parameter":
// validate semanticFormData1
test = data.in !== "formdata";
local.throwSwaggerError(!test && {
data: data.in,
errorType: "semanticFormData1",
prefix: option.prefix.concat(["in"])
});
// validate semanticFormData3
test = data.type !== "file" || data.in === "formData";
local.throwSwaggerError(!test && {
data: data,
errorType: "semanticFormData3",
prefix: option.prefix
});
// validate semanticParameters2
test = data.in === "body" || !local.isNullOrUndefined(data.type);
local.throwSwaggerError(!test && {
data: data,
errorType: "semanticParameters2",
prefix: option.prefix
});
break;
case...n/a
swaggerValidateFile = function (option, onError) {
/*
* this function will validate the json-file option.file
*/
local.onNext(option, function (error, data) {
switch (option.modeNext) {
case 1:
if (typeof option.data === "string") {
option.onNext(null, option.data);
return;
}
// fetch url
if ((
/^(?:http|https):\/\//
).test(option.file)) {
local.ajax({
url: option.file
}, function (error, xhr) {
option.onNext(error, xhr && xhr.responseText);
});
return;
}
// read file
local.fs.readFile(option.file, "utf8", option.onNext);
break;
case 2:
// jslint
local.jslint.jslintAndPrint(data, option.file);
local.assertThrow(
!local.jslint.jslintResult.errorText,
local.jslint.jslintResult.errorText.replace((
/\u001b\[\d*m/g
), "")
);
// validate
local.swgg.swaggerValidate(JSON.parse(data));
option.onNext();
break;
default:
console.error(
error
? "\u001b[31mswagger-validate - failed - " + option.file + "\n"
+ error.message + "\u001b[39m"
: "swagger-validate - passed - " + option.file
);
onError(error);
}
});
option.modeNext = 0;
option.onNext();
}...
local.cliDict = {};
local.cliDict._default = function () {
/*
* <file/url>
* will swagger-validate <file/url>
*/
local.swaggerValidateFile({
file: process.argv[2]
}, function (error) {
process.exit(Boolean(error));
});
};
// run the cli
...