@backland/schema
Version:
TypeScript schema declaration and validation library with static type inference
283 lines • 8.79 kB
JavaScript
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); }
import { setByPath } from '@backland/utils';
import { BJSON } from '@backland/utils';
import { RuntimeError } from '@backland/utils';
import { expectedType } from '@backland/utils';
import { getByPath } from '@backland/utils';
import { getKeys } from '@backland/utils';
import { getTypeName } from '@backland/utils';
import { nonNullValues } from '@backland/utils';
import { __getCachedFieldInstance, createObjectType, isObject, parseField, parseObjectField } from './ObjectType';
import { AliasField } from './fields/AliasField';
import { LiteralField } from './fields/LiteralField';
import { E164_PHONE_REGEX } from './fields/PhoneField';
import { isHiddenFieldName } from './isHiddenFieldName';
import { parseTypeName } from './parseTypeName';
/**
* Converts an object to a json-schema format
* @param parentName
* @param object
* @param options
*/
export function objectToJSON(parentName, object) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
ignoreDefaultValues: true
};
var definition;
if (isObject(object)) {
definition = object.definition;
} else {
// @ts-ignore
definition = createObjectType(object).definition;
}
var description = isObject(object) ? object.description : undefined;
var topProperties = {};
var required = [];
var topJSON = {
additionalProperties: false,
properties: topProperties,
required,
title: parentName,
type: 'object'
};
if (description) {
topJSON.description = description;
}
var composers = [];
getKeys(definition).forEach(fieldName => {
if (isHiddenFieldName(fieldName)) return;
var field = definition[fieldName];
if (field.hidden) return;
var parsedField = parseGraphQLField({
field,
fieldName,
options,
parentName
});
if (parsedField.required) {
required.push(fieldName);
}
topProperties[fieldName] = parsedField.jsonItem;
composers.push(...parsedField.composers);
});
composers.forEach(composer => {
var value = composer.compose(topProperties);
setByPath(topProperties, composer.key, value);
});
return topJSON;
}
function parseGraphQLField(params) {
var {
field,
fieldName,
parentName,
options
} = params;
field = parseField(field);
var {
ignoreDefaultValues
} = options;
var {
type,
list,
optional,
description,
defaultValue
} = field;
var composers = [];
nonNullValues({
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' ? parseObjectField(fieldName, field.def.of) : _objectSpread(_objectSpread({}, field), {}, {
list: false
}),
fieldName,
options,
parentName
});
return {
composers,
jsonItem: {
items: parsedListItem.jsonItem,
type: 'array'
},
required: !optional
};
}
var typeParsers = {
ID() {
jsonItem.type = 'string';
jsonItem.tsType = 'ID';
},
alias() {
var type = __getCachedFieldInstance(field);
AliasField.assert(type);
composers.push({
compose(parent) {
if (typeof type.def === 'string') {
return getByPath(parent, type.def);
} else {
return parseGraphQLField({
field: type.utils.fieldType.asFinalFieldDef,
fieldName,
options,
parentName
}).jsonItem;
}
},
key: fieldName
});
},
any() {
jsonItem.type = 'any';
},
array() {
// handled above
},
boolean() {
jsonItem.type = 'boolean';
},
cursor() {
jsonItem.type = 'object';
jsonItem.tsType = 'Cursor';
},
date() {
jsonItem.type = 'string';
jsonItem.format = 'date-time';
jsonItem.tsType = 'Date';
},
email() {
jsonItem.type = 'string';
jsonItem.tsType = 'Email';
},
enum() {
var def = field.def;
expectedType({
def
}, 'array');
if (def.length == 1) {
jsonItem.const = def[0];
} else {
jsonItem.type = 'string';
jsonItem.enum = def;
}
},
float() {
jsonItem.type = 'number';
},
int() {
jsonItem.type = 'integer';
},
literal() {
if (!LiteralField.isFinalTypeDef(field)) throw 'err';
var parsed = field.def['__o.proto__'] === 'String' ? field.def.value : BJSON.parse(field.def.value);
jsonItem.const = parsed;
var tsType = BJSON.stringify(parsed, {
handler: _ref => {
var _serializer$formatter;
var {
serializer,
value
} = _ref;
var typeName = 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: str => "".concat(str)
});
jsonItem.tsType = tsType;
},
meta() {},
null() {
jsonItem.type = 'null';
},
object() {
var objectName = parseTypeName({
field,
fieldName: '',
parentName: parentName || ''
});
Object.assign(jsonItem, objectToJSON(objectName, field.def, options), {
title: ''
});
},
phone() {
Object.assign(jsonItem, {
maxLength: 20,
minLength: 10,
pattern: E164_PHONE_REGEX.toString()
});
jsonItem.tsType = 'Phone';
},
record() {
if (field.type !== 'record' || !field.def) {
throw new RuntimeError("invalid record field definition.", {
fieldDef: field
});
}
jsonItem.type = 'object';
},
string() {
jsonItem.type = 'string';
},
ulid() {
jsonItem.type = 'string';
jsonItem.tsType = 'Ulid';
},
undefined() {
jsonItem.type = 'null';
},
union() {
var def = field.def;
expectedType({
def
}, 'array');
jsonItem.anyOf = def.map(type => {
return parseGraphQLField({
field: type,
fieldName,
options,
parentName
}).jsonItem;
});
},
unknown() {
jsonItem.type = 'any';
jsonItem.tsType = 'unknown';
}
};
if (!typeParsers[type]) {
throw new RuntimeError("invalid field type ".concat(type), {
field
}, 0, 20);
}
typeParsers[type]();
return {
composers,
jsonItem,
required
};
}
//# sourceMappingURL=objectToJSON.js.map