@backland/schema
Version:
TypeScript schema declaration and validation library with static type inference
197 lines • 10.6 kB
JavaScript
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
export var EnumType = /*#__PURE__*/_createClass(function EnumType(value) {
_classCallCheck(this, EnumType);
_defineProperty(this, "value", void 0);
this.value = value;
});
export var VariableType = /*#__PURE__*/function () {
function VariableType(value) {
_classCallCheck(this, VariableType);
_defineProperty(this, "value", void 0);
this.value = value;
}
_createClass(VariableType, [{
key: "toJSON",
value: function toJSON() {
return "$".concat(this.value);
}
}]);
return VariableType;
}();
export var configFields = ['__args', '__alias', '__aliasFor', '__variables', '__directives', '__on', '__all_on', '__typeName', '__name'];
export function stringifyArgs(obj_from_json) {
if (obj_from_json instanceof EnumType) {
return obj_from_json.value;
}
// variables should be prefixed with dollar sign and not quoted
else if (obj_from_json instanceof VariableType) {
return "$".concat(obj_from_json.value);
}
// Cheers to Derek: https://stackoverflow.com/questions/11233498/json-stringify-without-quotes-on-properties
else if (_typeof(obj_from_json) !== 'object' || obj_from_json === null) {
// not an object, stringify using native function
return JSON.stringify(obj_from_json);
} else if (Array.isArray(obj_from_json)) {
return "[".concat(obj_from_json.map(function (item) {
return stringifyArgs(item);
}).join(', '), "]");
}
// Implements recursive object serialization according to JSON spec
// but without quotes around the keys.
var props = Object.keys(obj_from_json).map(function (key) {
return "".concat(key, ": ").concat(stringifyArgs(obj_from_json[key]));
}).join(', ');
return "{".concat(props, "}");
}
export function buildArgs(argsObj) {
var args = [];
for (var argName in argsObj) {
args.push("".concat(argName, ": ").concat(stringifyArgs(argsObj[argName])));
}
return args.join(', ');
}
function buildVariables(varsObj) {
var args = [];
for (var varName in varsObj) {
args.push("$".concat(varName, ": ").concat(varsObj[varName]));
}
return args.join(', ');
}
function buildDirectives(dirsObj) {
var directiveName = Object.keys(dirsObj)[0];
var directiveValue = dirsObj[directiveName];
if (typeof directiveValue === 'boolean' || _typeof(directiveValue) === 'object' && Object.keys(directiveValue).length === 0) {
return directiveName;
} else if (_typeof(directiveValue) === 'object') {
var args = [];
for (var argName in directiveValue) {
var argVal = stringifyArgs(directiveValue[argName]).replace(/"/g, '');
args.push("".concat(argName, ": ").concat(argVal));
}
return "".concat(directiveName, "(").concat(args.join(', '), ")");
} else {
throw new Error("Unsupported type for directive: ".concat(_typeof(directiveValue), ". Types allowed: object, boolean.\n") + "Offending object: ".concat(JSON.stringify(dirsObj)));
}
}
function getIndent(level) {
return Array(level * 2 + 1).join(' ');
}
function filterNonConfigFields(fieldName, ignoreFields) {
// Returns true if fieldName is not a 'configField'.
return configFields.indexOf(fieldName) == -1 && ignoreFields.indexOf(fieldName) == -1;
}
function convertQuery(node, level, output, options) {
Object.keys(node).filter(function (key) {
return filterNonConfigFields(key, options.ignoreFields);
}).forEach(function (key) {
var value = node[key];
if (_typeof(value) === 'object') {
if (Array.isArray(value)) {
value = value.find(function (item) {
return item && _typeof(item) === 'object';
});
if (!value) {
output.push(["".concat(key), level]);
return;
}
}
var fieldCount = Object.keys(value).filter(function (keyCount) {
return filterNonConfigFields(keyCount, options.ignoreFields);
}).length;
var subFields = fieldCount > 0;
var argsExist = _typeof(value.__args) === 'object' && Object.keys(value.__args).length > 0;
var directivesExist = _typeof(value.__directives) === 'object';
var fullFragmentsExist = value.__all_on instanceof Array;
var partialFragmentsExist = _typeof(value.__on) === 'object';
var token = "".concat(key);
if (typeof value.__name === 'string') {
token = "".concat(token, " ").concat(value.__name);
}
if (typeof value.__aliasFor === 'string') {
token = "".concat(token, ": ").concat(value.__aliasFor);
}
if (_typeof(value.__variables) === 'object' && Object.keys(value.__variables).length > 0) {
token = "".concat(token, " (").concat(buildVariables(value.__variables), ")");
} else if (argsExist || directivesExist) {
var argsStr = '';
var dirsStr = '';
if (directivesExist) {
dirsStr = Object.entries(value.__directives).map(function (item) {
return "@".concat(buildDirectives(_defineProperty({}, item[0], item[1])));
}).join(' ');
}
if (argsExist) {
argsStr = "(".concat(buildArgs(value.__args), ")");
}
var spacer = directivesExist && argsExist ? ' ' : '';
token = "".concat(token, " ").concat(argsStr).concat(spacer).concat(dirsStr);
}
output.push([token + (subFields || partialFragmentsExist || fullFragmentsExist ? ' {' : ''), level]);
convertQuery(value, level + 1, output, options);
if (fullFragmentsExist) {
value.__all_on.forEach(function (fullFragment) {
output.push(["...".concat(fullFragment), level + 1]);
});
}
if (partialFragmentsExist) {
var inlineFragments = value.__on instanceof Array ? value.__on : [value.__on];
inlineFragments.forEach(function (inlineFragment) {
var name = inlineFragment.__typeName;
output.push(["... on ".concat(name, " {"), level + 1]);
convertQuery(inlineFragment, level + 2, output, options);
output.push(['}', level + 1]);
});
}
if (subFields || partialFragmentsExist || fullFragmentsExist) {
output.push(['}', level]);
}
} else if (options.includeFalsyKeys === true || value) {
output.push(["".concat(key), level]);
}
});
}
export function objectToQuery(query) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (!query || _typeof(query) != 'object') {
throw new Error('query object not specified');
}
if (Object.keys(query).length == 0) {
throw new Error('query object has no data');
}
if (!(options.ignoreFields instanceof Array)) {
options.ignoreFields = [];
}
var queryLines = [];
convertQuery(query, 0, queryLines, options);
var output = '';
queryLines.forEach(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
line = _ref2[0],
level = _ref2[1];
if (options.pretty) {
if (output) {
output += '\n';
}
output += getIndent(level) + line;
} else {
if (output) {
output += ' ';
}
output += line;
}
});
return output;
}
//# sourceMappingURL=objectToQuery.js.map