shyft
Version:
Model driven GraphQL API framework
157 lines (156 loc) • 6.61 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.processPreFilters = exports.convertFilterLevel = exports.processFilter = exports.validateFilterLevel = void 0;
var Entity_1 = require("./entity/Entity");
var util_1 = require("./util");
var ObjectDataType_1 = require("./datatype/ObjectDataType");
var logicFilters = ['$and', '$or'];
var deepFilter = '$filter';
var preFilter = '$pre_filter';
var noResultFilter = '$noResult';
var validateFilterLevel = function (filters, attributes, path, storageType) {
var ret = {};
util_1.passOrThrow(!path || util_1.isArray(path, true), function () {
return 'optional path in validateFilterLevel() needs to be an array';
});
var errorLocation = path ? " at '" + path.join('.') + "'" : '';
util_1.passOrThrow(util_1.isMap(filters), function () { return "filter" + errorLocation + " needs to be an object of filter criteria"; });
util_1.passOrThrow(util_1.isMap(attributes, true), function () {
return 'validateFilterLevel() expects an attribute map';
});
util_1.mapOverProperties(filters, function (value, filter) {
if (logicFilters.includes(filter)) {
var newPath = path ? path.slice() : [];
newPath.push(filter);
value.map(function (newFilter) {
return exports.validateFilterLevel(newFilter, attributes, path, storageType);
});
return;
}
if (filter.indexOf(deepFilter) === 0) {
var newPath = path ? path.slice() : [];
newPath.push(filter);
var attributeName_1 = filter.replace(deepFilter + ".", '');
var targetEntity = attributes[attributeName_1].type;
exports.validateFilterLevel(value, targetEntity.getAttributes(), path, storageType);
return;
}
var attributeName = filter;
var attribute = attributes[attributeName];
util_1.passOrThrow(attribute, function () {
return "Unknown attribute name '" + attributeName + "' used in filter" + errorLocation;
});
util_1.passOrThrow(!attribute.mutationInput, function () {
return "Mutation input attribute '" + attributeName + "' not allowed in filter" + errorLocation;
});
if (util_1.isMap(value)) {
var storageDataType_1;
if (Entity_1.isEntity(attribute.type)) {
var primaryAttribute = attribute.type.getPrimaryAttribute();
storageDataType_1 = storageType.convertToStorageDataType(primaryAttribute.type);
}
else {
storageDataType_1 = storageType.convertToStorageDataType(attribute.type);
}
var operators = Object.keys(value);
operators.map(function (operator) {
if (operator === noResultFilter) {
return;
}
if (operator === preFilter && attribute.primary) {
return;
}
var operatorCapabilityName = operator.replace('$', '');
util_1.passOrThrow(storageDataType_1.capabilities.indexOf(operatorCapabilityName) >= 0, function () {
return "Unknown or incompatible operator '" + operator + "' used on '" + attributeName + "' in filter" + errorLocation;
});
});
}
});
return ret;
};
exports.validateFilterLevel = validateFilterLevel;
var processFilter = function (entity, args, storageType) {
var filter = args.filter;
if (!filter) {
return {};
}
exports.validateFilterLevel(filter, entity.getAttributes(), null, storageType);
var where = __assign({}, filter);
return where;
};
exports.processFilter = processFilter;
var convertFilterLevel = function (filterShaper, filterLevel) {
var converted = filterShaper(filterLevel);
var filterLevelKeys = Object.keys(converted);
var ret = {};
filterLevelKeys.map(function (key) {
var filter = filterLevel[key];
if (filter) {
if (util_1.isMap(filter)) {
ret[key] = exports.convertFilterLevel(filterShaper, filter);
}
else if (logicFilters.includes(key)) {
ret[key] = filter.map(function (item) { return exports.convertFilterLevel(filterShaper, item); });
}
else {
ret[key] = converted[key];
}
}
});
filterLevelKeys.map(function (key) {
if (typeof converted[key] !== 'undefined' &&
typeof ret[key] === 'undefined') {
ret[key] = converted[key];
}
});
return ret;
};
exports.convertFilterLevel = convertFilterLevel;
var isPreFilter = function (preFilterDefinition) {
if (util_1.isMap(preFilterDefinition)) {
if (util_1.isFunction(preFilterDefinition.resolve)) {
if (!preFilterDefinition.input ||
ObjectDataType_1.isObjectDataType(preFilterDefinition.input)) {
return true;
}
if (util_1.isFunction(preFilterDefinition.input)) {
var dataTypeBuilder = preFilterDefinition.input;
var inputType = dataTypeBuilder({
setup: {
name: 'temporary',
description: 'temporary',
},
});
if (ObjectDataType_1.isObjectDataType(inputType)) {
return true;
}
}
}
}
return false;
};
var processPreFilters = function (entity, preFilters) {
util_1.passOrThrow(util_1.isMap(preFilters), function () {
return "Entity '" + entity.name + "' preFilters definition needs to be a map with individual preFilters";
});
Object.keys(preFilters).map(function (preFilterName) {
var preFilterDefinition = preFilters[preFilterName];
util_1.passOrThrow(isPreFilter(preFilterDefinition), function () {
return "Invalid preFilter definition '" + preFilterName + "' for entity '" + entity.name + "'";
});
});
return preFilters;
};
exports.processPreFilters = processPreFilters;