ts-comply
Version:
TypeTools is a Typescript library for providing extensible tooling runtime validations and type helpers.
372 lines • 16.3 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.CommonValidationsNamedImpl = exports.CommonValidations = exports.Validatable = exports.ValidatableExtensionData = exports.ValidatableSettings = void 0;
var type_tools_1 = require("./type-tools");
var data_importable_1 = require("./data-importable");
var properties_controller_1 = require("./properties-controller");
var context_1 = require("./context");
var class_lineage_1 = require("./class-lineage");
var common_iface_1 = require("./upstream/common.iface");
var ValidatableSettings = exports.ValidatableSettings = (function (_super) {
__extends(ValidatableSettings, _super);
function ValidatableSettings(init) {
var _this = _super.call(this, init) || this;
_this.extensionValidatable = ValidatableSettings.extensionValidatable;
if (init) {
Object.assign(_this, init);
}
return _this;
}
ValidatableSettings.extensionValidatable = 'Validatable';
return ValidatableSettings;
}(properties_controller_1.PropertiesControllerSettings));
var ValidatableExtensionData = (function () {
function ValidatableExtensionData() {
}
return ValidatableExtensionData;
}());
exports.ValidatableExtensionData = ValidatableExtensionData;
var Validatable = (function () {
function Validatable(settings) {
this.settings = (0, type_tools_1.settingsInitialize)(ValidatableSettings, settings);
}
Validatable.getExtensionData = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
return type_tools_1.TypeToolsBase.getExtension(target, settings.extensionValidatable, settings);
};
Validatable.typeCheck = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
return target && !!Validatable.getExtensionData(target, settings);
};
Validatable.implementOn = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
if (!type_tools_1.TypeToolsBase.checkContext(Validatable)) {
return false;
}
if (!Validatable.getExtensionData(target, settings)) {
data_importable_1.DataImportable.implementOn(target);
properties_controller_1.PropertiesController.implementOn(target, settings);
var pcExtension = properties_controller_1.PropertiesController.getExtensionData(target, settings);
var managedProps_1 = pcExtension.managed;
var extension_1 = { errors: [], cancels: [] };
pcExtension.oncancels.push(function (tracer) {
context_1.Context.validationError = tracer.trace;
if (!context_1.Context.trackCancels) {
return;
}
var reg = managedProps_1[tracer.e.property];
if (reg.extension.validatable) {
extension_1.cancels.push(tracer);
}
});
pcExtension.onerrors.push(function (tracer) {
context_1.Context.validationError = tracer.trace;
if (!context_1.Context.trackErrors) {
return;
}
var reg = managedProps_1[tracer.e.property];
if (reg.extension.validatable) {
extension_1.errors.push(tracer);
}
});
type_tools_1.TypeToolsBase.addExtension(target, settings.extensionValidatable, extension_1);
}
return true;
};
Validatable.enforce = function (target, options, setterRubric, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
if (!Validatable.implementOn(target, settings)) {
return;
}
var type = class_lineage_1.ClassLineage.typeOf(target);
if (!type.validationRules) {
type.validationRules = {};
}
if (!options) {
options = {};
}
if (context_1.Context.current && !context_1.Context.current.test) {
var type_1 = context_1.Context.current;
type_1.test = type_1.check = function (target2, throwError) {
if (throwError === void 0) { throwError = false; }
return Validatable.test(target2, type_1, throwError);
};
}
var validatedKeys = Object.keys(setterRubric);
var descriptorsRubric = {};
for (var _i = 0, validatedKeys_1 = validatedKeys; _i < validatedKeys_1.length; _i++) {
var propName = validatedKeys_1[_i];
type.validationRules[propName] = setterRubric[propName];
descriptorsRubric[propName] = { set: setterRubric[propName] };
}
var manageOptions = {};
if (options.prepend) {
manageOptions.prepend = true;
}
properties_controller_1.PropertiesController.manage(target, manageOptions, descriptorsRubric, settings);
var managedProps = properties_controller_1.PropertiesController.getExtensionData(target, settings).managed;
for (var _a = 0, validatedKeys_2 = validatedKeys; _a < validatedKeys_2.length; _a++) {
var propName = validatedKeys_2[_a];
if (managedProps[propName]) {
managedProps[propName].extension.validatable = true;
}
}
data_importable_1.DataImportable.getExtensionData(target).import(options.init);
};
Validatable.check = function (data, againstType, throwError) {
if (throwError === void 0) { throwError = false; }
return Validatable.test(data, againstType, throwError);
};
Validatable.testProp = function (ruleType, propname, value, thisArg) {
if (!ruleType.validationRules) {
return true;
}
var setterRubric = ruleType.validationRules[propname];
var e = new properties_controller_1.PropertyAccessEvent({
property: propname,
className: ruleType.name,
classRealPath: (0, common_iface_1.typeFullName)(ruleType),
path: ruleType.name + '.' + propname,
class: ruleType,
value: value,
});
var passed = true;
try {
setterRubric.apply(thisArg, [value, e]);
}
catch (e) {
passed = false;
}
if (e.thrown || e.data.canceled) {
passed = false;
}
return passed;
};
Validatable.test = function (data, againstType, throwError) {
if (throwError === void 0) { throwError = false; }
if (!data) {
if (throwError) {
throw type_tools_1.TypeToolsBase.reusedTrace('Validatable.validate::null_data', 'Cannot validate null data', true);
}
else {
return false;
}
}
var inst = type_tools_1.TypeToolsBase.getSampleInstance(againstType);
var isValType = true;
var extBase = inst[type_tools_1.TypeToolsSettings.typeToolsKey];
if (!extBase) {
isValType = false;
}
var valExt = extBase ? extBase[ValidatableSettings.extensionValidatable] : null;
if (!valExt) {
isValType = false;
}
if (!isValType) {
if (throwError) {
throw type_tools_1.TypeToolsBase.reusedTrace('Validatable.validate::not_validatable', "".concat((0, common_iface_1.typeFullName)(againstType), " type is not validatable."));
}
else {
return false;
}
}
var skel = type_tools_1.TypeToolsBase.getSkeleton(againstType);
var throwErrorsSaved = context_1.Context.throwErrors;
var trackErrorsSaved = context_1.Context.trackErrors;
var trackCancelsSaved = context_1.Context.trackCancels;
context_1.Context.throwErrors = context_1.Context.trackErrors = context_1.Context.trackCancels = false;
var error;
try {
data_importable_1.DataImportable.getExtensionData(inst).import(data, skel, true);
}
catch (e) {
error = e;
}
context_1.Context.throwErrors = throwErrorsSaved;
context_1.Context.trackErrors = trackErrorsSaved;
context_1.Context.trackCancels = trackCancelsSaved;
if (type_tools_1.TypeToolsBase.topError) {
if (throwError) {
throw type_tools_1.TypeToolsBase.topError;
}
return false;
}
if (type_tools_1.TypeToolsBase.topCancel) {
return false;
}
return true;
};
Validatable.convertInto = function (type, data, throwOnError) {
if (throwOnError === void 0) { throwOnError = true; }
var validatableData;
try {
return validatableData = new type(data);
}
catch (e) {
if (throwOnError) {
throw e;
}
return null;
}
};
Validatable.errorsOf = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
var extension = Validatable.getExtensionData(target, settings);
return extension.errors;
};
Validatable.cancelsOf = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
var extension = Validatable.getExtensionData(target, settings);
return extension.cancels;
};
Validatable.resultOf = function (target, settings) {
if (settings === void 0) { settings = ValidatableSettings; }
var extension = Validatable.getExtensionData(target, settings);
return extension.errors.length === 0 && extension.cancels.length === 0;
};
Validatable.prototype.getExtensionData = function (target) { return Validatable.getExtensionData(target, this.settings); };
Validatable.prototype.typeCheck = function (target) { return Validatable.typeCheck(target, this.settings); };
Validatable.prototype.implementOn = function (target) { return Validatable.implementOn(target, this.settings); };
Validatable.prototype.enforce = function (target, options, setterRubric) {
return Validatable.enforce(target, options, setterRubric, this.settings);
};
Validatable.prototype.convertInto = function (type, data, throwOnError) {
if (throwOnError === void 0) { throwOnError = true; }
return Validatable.convertInto(type, data, throwOnError);
};
Validatable.prototype.test = function (data, againstType, throwError) {
if (throwError === void 0) { throwError = false; }
return Validatable.test(data, againstType, throwError);
};
return Validatable;
}());
exports.Validatable = Validatable;
context_1.Context.cast = function (a, type) {
var unlockedSaved = context_1.Context.defineOnUnlock;
context_1.Context.defineOnUnlock = true;
var cast = Validatable.convertInto(type, a, false);
context_1.Context.defineOnUnlock = unlockedSaved;
return cast;
};
exports.CommonValidations = {
notNull: 'notNull',
boolean: 'boolean',
number: 'number',
string: 'string',
object: 'object',
array: 'array',
function: 'function',
modelInstance: 'modelInstance',
modelCollection: 'modelCollection',
list: 'list',
dict: 'dict',
custom: function (validator) { return validator; },
extends: function (type) {
var typename = typeof type === 'string' ? type : (0, common_iface_1.typeFullName)(type);
return function (e, value) {
if (!type) {
return false;
}
return value && typeof value === 'object' && class_lineage_1.ClassLineage.mapOf(value)[typename];
};
},
extendsNot: function (type) {
var typename = typeof type === 'string' ? type : (0, common_iface_1.typeFullName)(type);
return function (e, value) {
if (!type) {
return true;
}
return !(value && typeof value === 'object' && class_lineage_1.ClassLineage.mapOf(value)[typename]);
};
},
class: function (type) {
var typename = typeof type === 'string' ? type : (0, common_iface_1.typeFullName)(type);
return function (e, value) {
if (!type) {
return false;
}
return value && typeof value === 'object' && value.constructor.name === typename;
};
},
classIn: function () {
var types = [];
for (var _i = 0; _i < arguments.length; _i++) {
types[_i] = arguments[_i];
}
var typenames = types.map(function (t) { return typeof t === 'string' ? t : (0, common_iface_1.typeFullName)(t); });
return function (e, value) {
if (!types || types.length === 0) {
return false;
}
return value && typeof value === 'object' && typenames.indexOf(value.constructor.name) >= 0;
};
},
classNot: function (type) {
var typename = typeof type === 'string' ? type : (0, common_iface_1.typeFullName)(type);
return function (e, value) {
if (!type) {
return false;
}
return !(value && typeof value === 'object' && value.constructor.name === typename);
};
},
classNotIn: function () {
var types = [];
for (var _i = 0; _i < arguments.length; _i++) {
types[_i] = arguments[_i];
}
var typenames = types.map(function (t) { return typeof t === 'string' ? t : (0, common_iface_1.typeFullName)(t); });
return function (e, value) {
if (!types || types.length === 0) {
return true;
}
return !(value && typeof value === 'object' && typenames.indexOf(value.constructor.name) >= 0);
};
},
range: function () {
var exprs = [];
for (var _i = 0; _i < arguments.length; _i++) {
exprs[_i] = arguments[_i];
}
},
email: {
toString: function () { return 'email'; },
},
phone: {
toString: function () { return 'phone'; },
intl: 'phone_intl',
},
phoneNumber: 1,
};
exports.CommonValidationsNamedImpl = {
'notNull': function (e, value) { return value !== null && value !== undefined; },
'boolean': function (e, value) { return value === true || value === false; },
'number': function (e, value) { return typeof value === 'number'; },
'integer': function (e, value) { return Math.floor(value) === value; },
'naturalNumber': function (e, value) { return value > 0 && Math.floor(value) === value; },
'wholeNumber': function (e, value) { return value >= 0 && Math.floor(value) === value; },
'string': function (e, value) { return typeof value === 'string'; },
'object': function (e, value) { return typeof value === 'object'; },
'array': function (e, value) { return Array.isArray(value); },
'function': function (e, value) { return (0, type_tools_1.isFunction)(value); },
'modelInstance': function (e, value) { return type_tools_1.TypeToolsBase.typeCheck(value); },
'modelCollection': function (e, value) { return (0, type_tools_1.isModelCollection)(value); },
'list': function (e, value) { return type_tools_1.List.check(value); },
'dict': function (e, value) { return type_tools_1.Dict.check(value); },
};
//# sourceMappingURL=validatable.js.map