@backland/schema
Version:
TypeScript schema declaration and validation library with static type inference
284 lines (283 loc) • 11.2 kB
JavaScript
;
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); }
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.objectToJSON = objectToJSON;
var _utils = require("@backland/utils");
var _ObjectType = require("./ObjectType");
var _AliasField = require("./fields/AliasField");
var _LiteralField = require("./fields/LiteralField");
var _PhoneField = require("./fields/PhoneField");
var _isHiddenFieldName = require("./isHiddenFieldName");
var _parseTypeName = require("./parseTypeName");
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
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); }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
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; }
/**
* Converts an object to a json-schema format
* @param parentName
* @param object
* @param options
*/
function objectToJSON(parentName, object) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
ignoreDefaultValues: true
};
var definition;
if ((0, _ObjectType.isObject)(object)) {
definition = object.definition;
} else {
// @ts-ignore
definition = (0, _ObjectType.createObjectType)(object).definition;
}
var description = (0, _ObjectType.isObject)(object) ? object.description : undefined;
var topProperties = {};
var required = [];
var topJSON = {
additionalProperties: false,
properties: topProperties,
required: required,
title: parentName,
type: 'object'
};
if (description) {
topJSON.description = description;
}
var composers = [];
(0, _utils.getKeys)(definition).forEach(function (fieldName) {
if ((0, _isHiddenFieldName.isHiddenFieldName)(fieldName)) return;
var field = definition[fieldName];
if (field.hidden) return;
var parsedField = parseGraphQLField({
field: field,
fieldName: fieldName,
options: options,
parentName: parentName
});
if (parsedField.required) {
required.push(fieldName);
}
topProperties[fieldName] = parsedField.jsonItem;
composers.push.apply(composers, _toConsumableArray(parsedField.composers));
});
composers.forEach(function (composer) {
var value = composer.compose(topProperties);
(0, _utils.setByPath)(topProperties, composer.key, value);
});
return topJSON;
}
function parseGraphQLField(params) {
var field = params.field,
fieldName = params.fieldName,
parentName = params.parentName,
options = params.options;
field = (0, _ObjectType.parseField)(field);
var ignoreDefaultValues = options.ignoreDefaultValues;
var _field = field,
type = _field.type,
list = _field.list,
optional = _field.optional,
description = _field.description,
defaultValue = _field.defaultValue;
var composers = [];
(0, _utils.nonNullValues)({
type: type
});
var required = !optional && type !== 'undefined';
var jsonItem = {
// title, // will generate extra types in typescript
};
if (ignoreDefaultValues) {
defaultValue = undefined;
}
if (defaultValue !== undefined) {
required = false;
jsonItem.default = defaultValue;
}
if (description) {
jsonItem.description = description;
}
if (type === 'array' || list) {
var parsedListItem = parseGraphQLField({
field: type === 'array' ? (0, _ObjectType.parseObjectField)(fieldName, field.def.of) : _objectSpread(_objectSpread({}, field), {}, {
list: false
}),
fieldName: fieldName,
options: options,
parentName: parentName
});
return {
composers: composers,
jsonItem: {
items: parsedListItem.jsonItem,
type: 'array'
},
required: !optional
};
}
var typeParsers = {
ID: function ID() {
jsonItem.type = 'string';
jsonItem.tsType = 'ID';
},
alias: function alias() {
var type = (0, _ObjectType.__getCachedFieldInstance)(field);
_AliasField.AliasField.assert(type);
composers.push({
compose: function compose(parent) {
if (typeof type.def === 'string') {
return (0, _utils.getByPath)(parent, type.def);
} else {
return parseGraphQLField({
field: type.utils.fieldType.asFinalFieldDef,
fieldName: fieldName,
options: options,
parentName: parentName
}).jsonItem;
}
},
key: fieldName
});
},
any: function any() {
jsonItem.type = 'any';
},
array: function array() {
// handled above
},
boolean: function boolean() {
jsonItem.type = 'boolean';
},
cursor: function cursor() {
jsonItem.type = 'object';
jsonItem.tsType = 'Cursor';
},
date: function date() {
jsonItem.type = 'string';
jsonItem.format = 'date-time';
jsonItem.tsType = 'Date';
},
email: function email() {
jsonItem.type = 'string';
jsonItem.tsType = 'Email';
},
enum: function _enum() {
var def = field.def;
(0, _utils.expectedType)({
def: def
}, 'array');
if (def.length == 1) {
jsonItem.const = def[0];
} else {
jsonItem.type = 'string';
jsonItem.enum = def;
}
},
float: function float() {
jsonItem.type = 'number';
},
int: function int() {
jsonItem.type = 'integer';
},
literal: function literal() {
if (!_LiteralField.LiteralField.isFinalTypeDef(field)) throw 'err';
var parsed = field.def['__o.proto__'] === 'String' ? field.def.value : _utils.BJSON.parse(field.def.value);
jsonItem.const = parsed;
var tsType = _utils.BJSON.stringify(parsed, {
handler: function handler(_ref) {
var _serializer$formatter;
var serializer = _ref.serializer,
value = _ref.value;
var typeName = (0, _utils.getTypeName)(value);
if (['Object', 'Array'].includes(typeName)) return;
if (typeName === 'String') return JSON.stringify(value);
if (typeName === 'Number') return value;
return (serializer === null || serializer === void 0 ? void 0 : (_serializer$formatter = serializer.formatter) === null || _serializer$formatter === void 0 ? void 0 : _serializer$formatter.tsName(value)) || typeName;
},
quoteValues: function quoteValues(str) {
return "".concat(str);
}
});
jsonItem.tsType = tsType;
},
meta: function meta() {},
null: function _null() {
jsonItem.type = 'null';
},
object: function object() {
var objectName = (0, _parseTypeName.parseTypeName)({
field: field,
fieldName: '',
parentName: parentName || ''
});
Object.assign(jsonItem, objectToJSON(objectName, field.def, options), {
title: ''
});
},
phone: function phone() {
Object.assign(jsonItem, {
maxLength: 20,
minLength: 10,
pattern: _PhoneField.E164_PHONE_REGEX.toString()
});
jsonItem.tsType = 'Phone';
},
record: function record() {
if (field.type !== 'record' || !field.def) {
throw new _utils.RuntimeError("invalid record field definition.", {
fieldDef: field
});
}
jsonItem.type = 'object';
},
string: function string() {
jsonItem.type = 'string';
},
ulid: function ulid() {
jsonItem.type = 'string';
jsonItem.tsType = 'Ulid';
},
undefined: function undefined() {
jsonItem.type = 'null';
},
union: function union() {
var def = field.def;
(0, _utils.expectedType)({
def: def
}, 'array');
jsonItem.anyOf = def.map(function (type) {
return parseGraphQLField({
field: type,
fieldName: fieldName,
options: options,
parentName: parentName
}).jsonItem;
});
},
unknown: function unknown() {
jsonItem.type = 'any';
jsonItem.tsType = 'unknown';
}
};
if (!typeParsers[type]) {
throw new _utils.RuntimeError("invalid field type ".concat(type), {
field: field
}, 0, 20);
}
typeParsers[type]();
return {
composers: composers,
jsonItem: jsonItem,
required: required
};
}
//# sourceMappingURL=objectToJSON.js.map