@cheetah.js/orm
Version:
A simple ORM for Cheetah.js
1,118 lines (1,078 loc) • 12.1 MB
JavaScript
// @bun
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __toCommonJS = (from) => {
const moduleCache = __toCommonJS.moduleCache ??= new WeakMap;
var cached = moduleCache.get(from);
if (cached)
return cached;
var to = __defProp({}, "__esModule", { value: true });
var desc = { enumerable: false };
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
moduleCache.set(from, to);
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __require = (id) => {
return import.meta.require(id);
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __legacyDecorateClassTS = function(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1;i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __legacyMetadataTS = (k, v) => {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
// /export/htdocs/p/framework/packages/core/dist/domain/provider-type.js
var require_provider_type = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProviderType = undefined;
var ProviderType;
(function(ProviderType2) {
ProviderType2["ROUTES"] = "routes";
ProviderType2["SERVICE"] = "service";
ProviderType2["PROVIDER"] = "provider";
ProviderType2["CONTROLLER"] = "controller";
})(ProviderType || (exports.ProviderType = ProviderType = {}));
});
// /export/htdocs/p/framework/packages/core/dist/domain/provider-scope.js
var require_provider_scope = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProviderScope = undefined;
var ProviderScope;
(function(ProviderScope2) {
ProviderScope2["REQUEST"] = "request";
ProviderScope2["INSTANCE"] = "instance";
ProviderScope2["SINGLETON"] = "singleton";
})(ProviderScope || (exports.ProviderScope = ProviderScope = {}));
});
// /export/htdocs/p/framework/packages/core/dist/utils/isObject.js
var require_isObject = __commonJS((exports) => {
var isObject = function(target) {
return typeof target === "object";
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isObject = undefined;
exports.isObject = isObject;
});
// /export/htdocs/p/framework/packages/core/dist/utils/classOf.js
var require_classOf = __commonJS((exports) => {
var getClass = function(target) {
return target.prototype ? target : target.constructor;
};
var classOf = function(target) {
return getClass(target);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.classOf = exports.getClass = undefined;
exports.getClass = getClass;
exports.classOf = classOf;
});
// /export/htdocs/p/framework/packages/core/dist/utils/isString.js
var require_isString = __commonJS((exports) => {
var isString = function(target) {
return typeof target === "string";
};
var isStringOrStringClass = function(target) {
return typeof target === "string" || target instanceof String || target === String;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isStringOrStringClass = exports.isString = undefined;
exports.isString = isString;
exports.isStringOrStringClass = isStringOrStringClass;
});
// /export/htdocs/p/framework/packages/core/dist/utils/isFunction.js
var require_isFunction = __commonJS((exports) => {
var isFunction = function(target) {
return typeof target === "function";
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isFunction = undefined;
exports.isFunction = isFunction;
});
// /export/htdocs/p/framework/packages/core/dist/utils/constructorOf.js
var require_constructorOf = __commonJS((exports) => {
var getConstructor = function(target) {
return typeof target === "function" ? target : target.constructor;
};
var constructorOf = function(target) {
return getConstructor(target);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.constructorOf = exports.getConstructor = undefined;
exports.getConstructor = getConstructor;
exports.constructorOf = constructorOf;
});
// /export/htdocs/p/framework/packages/core/dist/utils/toStringConstructor.js
var require_toStringConstructor = __commonJS((exports) => {
var toStringConstructor = function(target) {
const ctr = (0, constructorOf_1.constructorOf)(target);
const strings = ctr.toString().split("\n");
const ctrString = strings.find((s) => s.indexOf("constructor(") > -1) || "constructor()";
return `${ctrString.replace("{", "").trim()}`;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.toStringConstructor = undefined;
var constructorOf_1 = require_constructorOf();
exports.toStringConstructor = toStringConstructor;
});
// /export/htdocs/p/framework/packages/core/dist/utils/getConstructorArgNames.js
var require_getConstructorArgNames = __commonJS((exports) => {
var getConstructorArgNames = function(target) {
return (0, toStringConstructor_1.toStringConstructor)(target).split("constructor(")[1].split(")")[0].split(", ").filter(Boolean).map((s) => s.trim());
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getConstructorArgNames = undefined;
var toStringConstructor_1 = require_toStringConstructor();
exports.getConstructorArgNames = getConstructorArgNames;
});
// /export/htdocs/p/framework/packages/core/dist/utils/getValue.js
var require_getValue = __commonJS((exports) => {
var getValue = function(...args) {
const options = mapOptions(args);
let scope = options.scope;
const { expression, defaultValue, separator } = options;
if (!expression) {
return scope;
}
if (!scope) {
return defaultValue;
}
const keys = expression.split(separator);
const getValue2 = (key) => {
if (scope) {
if (scope[key] !== undefined || (0, isObject_1.isObject)(scope) && key in scope) {
return scope[key];
}
if ((0, isFunction_1.isFunction)(scope.get)) {
return scope.get(key);
}
}
};
while ((scope = getValue2(keys.shift())) && keys.length) {
}
return scope === undefined ? defaultValue : scope;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getValue = undefined;
var isFunction_1 = require_isFunction();
var isObject_1 = require_isObject();
var isString_1 = require_isString();
var mapOptions = (args) => {
const [expression, scope, defaultValue, separator = "."] = args;
if ((0, isObject_1.isObject)(scope) || (0, isString_1.isString)(expression)) {
return {
expression,
scope,
defaultValue,
separator
};
}
return {
expression: scope,
scope: expression,
defaultValue,
separator
};
};
exports.getValue = getValue;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/metadata/ValidationMetadata.js
var require_ValidationMetadata = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationMetadata = undefined;
class ValidationMetadata {
constructor(args) {
this.groups = [];
this.each = false;
this.context = undefined;
this.type = args.type;
this.name = args.name;
this.target = args.target;
this.propertyName = args.propertyName;
this.constraints = args === null || args === undefined ? undefined : args.constraints;
this.constraintCls = args.constraintCls;
this.validationTypeOptions = args.validationTypeOptions;
if (args.validationOptions) {
this.message = args.validationOptions.message;
this.groups = args.validationOptions.groups;
this.always = args.validationOptions.always;
this.each = args.validationOptions.each;
this.context = args.validationOptions.context;
}
}
}
exports.ValidationMetadata = ValidationMetadata;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation-schema/ValidationSchemaToMetadataTransformer.js
var require_ValidationSchemaToMetadataTransformer = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationSchemaToMetadataTransformer = undefined;
var ValidationMetadata_1 = require_ValidationMetadata();
class ValidationSchemaToMetadataTransformer {
transform(schema) {
const metadatas = [];
Object.keys(schema.properties).forEach((property) => {
schema.properties[property].forEach((validation) => {
const validationOptions = {
message: validation.message,
groups: validation.groups,
always: validation.always,
each: validation.each
};
const args = {
type: validation.type,
name: validation.name,
target: schema.name,
propertyName: property,
constraints: validation.constraints,
validationTypeOptions: validation.options,
validationOptions
};
metadatas.push(new ValidationMetadata_1.ValidationMetadata(args));
});
});
return metadatas;
}
}
exports.ValidationSchemaToMetadataTransformer = ValidationSchemaToMetadataTransformer;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/utils/convert-to-array.util.js
var require_convert_to_array_util = __commonJS((exports) => {
var convertToArray = function(val) {
if (val instanceof Map) {
return Array.from(val.values());
}
return Array.isArray(val) ? val : Array.from(val);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertToArray = undefined;
exports.convertToArray = convertToArray;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/utils/get-global.util.js
var require_get_global_util = __commonJS((exports) => {
var getGlobal = function() {
if (typeof globalThis !== "undefined") {
return globalThis;
}
if (typeof global !== "undefined") {
return global;
}
if (typeof window !== "undefined") {
return window;
}
if (typeof self !== "undefined") {
return self;
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getGlobal = undefined;
exports.getGlobal = getGlobal;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/utils/is-promise.util.js
var require_is_promise_util = __commonJS((exports) => {
var isPromise = function(p) {
return p !== null && typeof p === "object" && typeof p.then === "function";
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isPromise = undefined;
exports.isPromise = isPromise;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/utils/index.js
var require_utils = __commonJS((exports) => {
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
__createBinding(exports2, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require_convert_to_array_util(), exports);
__exportStar(require_get_global_util(), exports);
__exportStar(require_is_promise_util(), exports);
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/metadata/MetadataStorage.js
var require_MetadataStorage = __commonJS((exports) => {
var getMetadataStorage = function() {
const global2 = (0, utils_1.getGlobal)();
if (!global2.classValidatorMetadataStorage) {
global2.classValidatorMetadataStorage = new MetadataStorage;
}
return global2.classValidatorMetadataStorage;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getMetadataStorage = exports.MetadataStorage = undefined;
var ValidationSchemaToMetadataTransformer_1 = require_ValidationSchemaToMetadataTransformer();
var utils_1 = require_utils();
class MetadataStorage {
constructor() {
this.validationMetadatas = new Map;
this.constraintMetadatas = new Map;
}
get hasValidationMetaData() {
return !!this.validationMetadatas.size;
}
addValidationSchema(schema) {
const validationMetadatas = new ValidationSchemaToMetadataTransformer_1.ValidationSchemaToMetadataTransformer().transform(schema);
validationMetadatas.forEach((validationMetadata) => this.addValidationMetadata(validationMetadata));
}
addValidationMetadata(metadata) {
const existingMetadata = this.validationMetadatas.get(metadata.target);
if (existingMetadata) {
existingMetadata.push(metadata);
} else {
this.validationMetadatas.set(metadata.target, [metadata]);
}
}
addConstraintMetadata(metadata) {
const existingMetadata = this.constraintMetadatas.get(metadata.target);
if (existingMetadata) {
existingMetadata.push(metadata);
} else {
this.constraintMetadatas.set(metadata.target, [metadata]);
}
}
groupByPropertyName(metadata) {
const grouped = {};
metadata.forEach((metadata2) => {
if (!grouped[metadata2.propertyName])
grouped[metadata2.propertyName] = [];
grouped[metadata2.propertyName].push(metadata2);
});
return grouped;
}
getTargetValidationMetadatas(targetConstructor, targetSchema, always, strictGroups, groups) {
const includeMetadataBecauseOfAlwaysOption = (metadata) => {
if (typeof metadata.always !== "undefined")
return metadata.always;
if (metadata.groups && metadata.groups.length)
return false;
return always;
};
const excludeMetadataBecauseOfStrictGroupsOption = (metadata) => {
if (strictGroups) {
if (!groups || !groups.length) {
if (metadata.groups && metadata.groups.length)
return true;
}
}
return false;
};
const filteredForOriginalMetadatasSearch = this.validationMetadatas.get(targetConstructor) || [];
const originalMetadatas = filteredForOriginalMetadatasSearch.filter((metadata) => {
if (metadata.target !== targetConstructor && metadata.target !== targetSchema)
return false;
if (includeMetadataBecauseOfAlwaysOption(metadata))
return true;
if (excludeMetadataBecauseOfStrictGroupsOption(metadata))
return false;
if (groups && groups.length > 0)
return metadata.groups && !!metadata.groups.find((group) => groups.indexOf(group) !== -1);
return true;
});
const filteredForInheritedMetadatasSearch = [];
for (const [key, value] of this.validationMetadatas.entries()) {
if (targetConstructor.prototype instanceof key) {
filteredForInheritedMetadatasSearch.push(...value);
}
}
const inheritedMetadatas = filteredForInheritedMetadatasSearch.filter((metadata) => {
if (typeof metadata.target === "string")
return false;
if (metadata.target === targetConstructor)
return false;
if (metadata.target instanceof Function && !(targetConstructor.prototype instanceof metadata.target))
return false;
if (includeMetadataBecauseOfAlwaysOption(metadata))
return true;
if (excludeMetadataBecauseOfStrictGroupsOption(metadata))
return false;
if (groups && groups.length > 0)
return metadata.groups && !!metadata.groups.find((group) => groups.indexOf(group) !== -1);
return true;
});
const uniqueInheritedMetadatas = inheritedMetadatas.filter((inheritedMetadata) => {
return !originalMetadatas.find((originalMetadata) => {
return originalMetadata.propertyName === inheritedMetadata.propertyName && originalMetadata.type === inheritedMetadata.type;
});
});
return originalMetadatas.concat(uniqueInheritedMetadatas);
}
getTargetValidatorConstraints(target) {
return this.constraintMetadatas.get(target) || [];
}
}
exports.MetadataStorage = MetadataStorage;
exports.getMetadataStorage = getMetadataStorage;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation/ValidationError.js
var require_ValidationError = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationError = undefined;
class ValidationError {
toString(shouldDecorate = false, hasParent = false, parentPath = ``, showConstraintMessages = false) {
const boldStart = shouldDecorate ? `\x1B[1m` : ``;
const boldEnd = shouldDecorate ? `\x1B[22m` : ``;
const constraintsToString = () => {
var _a;
return (showConstraintMessages ? Object.values : Object.keys)((_a = this.constraints) !== null && _a !== undefined ? _a : {}).join(`, `);
};
const propConstraintFailed = (propertyName) => ` - property ${boldStart}${parentPath}${propertyName}${boldEnd} has failed the following constraints: ${boldStart}${constraintsToString()}${boldEnd} \n`;
if (!hasParent) {
return `An instance of ${boldStart}${this.target ? this.target.constructor.name : "an object"}${boldEnd} has failed the validation:\n` + (this.constraints ? propConstraintFailed(this.property) : ``) + (this.children ? this.children.map((childError) => childError.toString(shouldDecorate, true, this.property, showConstraintMessages)).join(``) : ``);
} else {
const formattedProperty = Number.isInteger(+this.property) ? `[${this.property}]` : `${parentPath ? `.` : ``}${this.property}`;
if (this.constraints) {
return propConstraintFailed(formattedProperty);
} else {
return this.children ? this.children.map((childError) => childError.toString(shouldDecorate, true, `${parentPath}${formattedProperty}`, showConstraintMessages)).join(``) : ``;
}
}
}
}
exports.ValidationError = ValidationError;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation/ValidationTypes.js
var require_ValidationTypes = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationTypes = undefined;
class ValidationTypes {
static isValid(type) {
return type !== "isValid" && type !== "getMessage" && Object.keys(this).map((key) => this[key]).indexOf(type) !== -1;
}
}
exports.ValidationTypes = ValidationTypes;
ValidationTypes.CUSTOM_VALIDATION = "customValidation";
ValidationTypes.NESTED_VALIDATION = "nestedValidation";
ValidationTypes.PROMISE_VALIDATION = "promiseValidation";
ValidationTypes.CONDITIONAL_VALIDATION = "conditionalValidation";
ValidationTypes.WHITELIST = "whitelistValidation";
ValidationTypes.IS_DEFINED = "isDefined";
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation/ValidationUtils.js
var require_ValidationUtils = __commonJS((exports) => {
var constraintToString = function(constraint) {
if (Array.isArray(constraint)) {
return constraint.join(", ");
}
if (typeof constraint === "symbol") {
constraint = constraint.description;
}
return `${constraint}`;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationUtils = exports.constraintToString = undefined;
exports.constraintToString = constraintToString;
class ValidationUtils {
static replaceMessageSpecialTokens(message, validationArguments) {
let messageString;
if (message instanceof Function) {
messageString = message(validationArguments);
} else if (typeof message === "string") {
messageString = message;
}
if (messageString && Array.isArray(validationArguments.constraints)) {
validationArguments.constraints.forEach((constraint, index) => {
messageString = messageString.replace(new RegExp(`\\\$constraint${index + 1}`, "g"), constraintToString(constraint));
});
}
if (messageString && validationArguments.value !== undefined && validationArguments.value !== null && typeof validationArguments.value === "string")
messageString = messageString.replace(/\$value/g, validationArguments.value);
if (messageString)
messageString = messageString.replace(/\$property/g, validationArguments.property);
if (messageString)
messageString = messageString.replace(/\$target/g, validationArguments.targetName);
return messageString;
}
}
exports.ValidationUtils = ValidationUtils;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation/ValidationExecutor.js
var require_ValidationExecutor = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationExecutor = undefined;
var ValidationError_1 = require_ValidationError();
var ValidationTypes_1 = require_ValidationTypes();
var ValidationUtils_1 = require_ValidationUtils();
var utils_1 = require_utils();
var MetadataStorage_1 = require_MetadataStorage();
class ValidationExecutor {
constructor(validator, validatorOptions) {
this.validator = validator;
this.validatorOptions = validatorOptions;
this.awaitingPromises = [];
this.ignoreAsyncValidations = false;
this.metadataStorage = (0, MetadataStorage_1.getMetadataStorage)();
}
execute(object, targetSchema, validationErrors) {
var _a, _b;
if (!this.metadataStorage.hasValidationMetaData && ((_a = this.validatorOptions) === null || _a === undefined ? undefined : _a.enableDebugMessages) === true) {
console.warn(`No validation metadata found. No validation will be performed. There are multiple possible reasons:\n - There may be multiple class-validator versions installed. You will need to flatten your dependencies to fix the issue.\n - This validation runs before any file with validation decorator was parsed by NodeJS.`);
}
const groups = this.validatorOptions ? this.validatorOptions.groups : undefined;
const strictGroups = this.validatorOptions && this.validatorOptions.strictGroups || false;
const always = this.validatorOptions && this.validatorOptions.always || false;
const forbidUnknownValues = ((_b = this.validatorOptions) === null || _b === undefined ? undefined : _b.forbidUnknownValues) === undefined || this.validatorOptions.forbidUnknownValues !== false;
const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(object.constructor, targetSchema, always, strictGroups, groups);
const groupedMetadatas = this.metadataStorage.groupByPropertyName(targetMetadatas);
if (this.validatorOptions && forbidUnknownValues && !targetMetadatas.length) {
const validationError = new ValidationError_1.ValidationError;
if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.target === undefined || this.validatorOptions.validationError.target === true)
validationError.target = object;
validationError.value = undefined;
validationError.property = undefined;
validationError.children = [];
validationError.constraints = { unknownValue: "an unknown value was passed to the validate function" };
validationErrors.push(validationError);
return;
}
if (this.validatorOptions && this.validatorOptions.whitelist)
this.whitelist(object, groupedMetadatas, validationErrors);
Object.keys(groupedMetadatas).forEach((propertyName) => {
const value = object[propertyName];
const definedMetadatas = groupedMetadatas[propertyName].filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.IS_DEFINED);
const metadatas = groupedMetadatas[propertyName].filter((metadata) => metadata.type !== ValidationTypes_1.ValidationTypes.IS_DEFINED && metadata.type !== ValidationTypes_1.ValidationTypes.WHITELIST);
if (value instanceof Promise && metadatas.find((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.PROMISE_VALIDATION)) {
this.awaitingPromises.push(value.then((resolvedValue) => {
this.performValidations(object, resolvedValue, propertyName, definedMetadatas, metadatas, validationErrors);
}));
} else {
this.performValidations(object, value, propertyName, definedMetadatas, metadatas, validationErrors);
}
});
}
whitelist(object, groupedMetadatas, validationErrors) {
const notAllowedProperties = [];
Object.keys(object).forEach((propertyName) => {
if (!groupedMetadatas[propertyName] || groupedMetadatas[propertyName].length === 0)
notAllowedProperties.push(propertyName);
});
if (notAllowedProperties.length > 0) {
if (this.validatorOptions && this.validatorOptions.forbidNonWhitelisted) {
notAllowedProperties.forEach((property) => {
const validationError = this.generateValidationError(object, object[property], property);
validationError.constraints = { [ValidationTypes_1.ValidationTypes.WHITELIST]: `property ${property} should not exist` };
validationError.children = undefined;
validationErrors.push(validationError);
});
} else {
notAllowedProperties.forEach((property) => delete object[property]);
}
}
}
stripEmptyErrors(errors) {
return errors.filter((error) => {
if (error.children) {
error.children = this.stripEmptyErrors(error.children);
}
if (Object.keys(error.constraints).length === 0) {
if (error.children.length === 0) {
return false;
} else {
delete error.constraints;
}
}
return true;
});
}
performValidations(object, value, propertyName, definedMetadatas, metadatas, validationErrors) {
const customValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION);
const nestedValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.NESTED_VALIDATION);
const conditionalValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.CONDITIONAL_VALIDATION);
const validationError = this.generateValidationError(object, value, propertyName);
validationErrors.push(validationError);
const canValidate = this.conditionalValidations(object, value, conditionalValidationMetadatas);
if (!canValidate) {
return;
}
this.customValidations(object, value, definedMetadatas, validationError);
this.mapContexts(object, value, definedMetadatas, validationError);
if (value === undefined && this.validatorOptions && this.validatorOptions.skipUndefinedProperties === true) {
return;
}
if (value === null && this.validatorOptions && this.validatorOptions.skipNullProperties === true) {
return;
}
if ((value === null || value === undefined) && this.validatorOptions && this.validatorOptions.skipMissingProperties === true) {
return;
}
this.customValidations(object, value, customValidationMetadatas, validationError);
this.nestedValidations(value, nestedValidationMetadatas, validationError);
this.mapContexts(object, value, metadatas, validationError);
this.mapContexts(object, value, customValidationMetadatas, validationError);
}
generateValidationError(object, value, propertyName) {
const validationError = new ValidationError_1.ValidationError;
if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.target === undefined || this.validatorOptions.validationError.target === true)
validationError.target = object;
if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.value === undefined || this.validatorOptions.validationError.value === true)
validationError.value = value;
validationError.property = propertyName;
validationError.children = [];
validationError.constraints = {};
return validationError;
}
conditionalValidations(object, value, metadatas) {
return metadatas.map((metadata) => metadata.constraints[0](object, value)).reduce((resultA, resultB) => resultA && resultB, true);
}
customValidations(object, value, metadatas, error) {
metadatas.forEach((metadata) => {
this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls).forEach((customConstraintMetadata) => {
if (customConstraintMetadata.async && this.ignoreAsyncValidations)
return;
if (this.validatorOptions && this.validatorOptions.stopAtFirstError && Object.keys(error.constraints || {}).length > 0)
return;
const validationArguments = {
targetName: object.constructor ? object.constructor.name : undefined,
property: metadata.propertyName,
object,
value,
constraints: metadata.constraints
};
if (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map)) {
const validatedValue = customConstraintMetadata.instance.validate(value, validationArguments);
if ((0, utils_1.isPromise)(validatedValue)) {
const promise = validatedValue.then((isValid) => {
if (!isValid) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
error.constraints[type] = message;
if (metadata.context) {
if (!error.contexts) {
error.contexts = {};
}
error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
}
}
});
this.awaitingPromises.push(promise);
} else {
if (!validatedValue) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
error.constraints[type] = message;
}
}
return;
}
const arrayValue = (0, utils_1.convertToArray)(value);
const validatedSubValues = arrayValue.map((subValue) => customConstraintMetadata.instance.validate(subValue, validationArguments));
const validationIsAsync = validatedSubValues.some((validatedSubValue) => (0, utils_1.isPromise)(validatedSubValue));
if (validationIsAsync) {
const asyncValidatedSubValues = validatedSubValues.map((validatedSubValue) => (0, utils_1.isPromise)(validatedSubValue) ? validatedSubValue : Promise.resolve(validatedSubValue));
const asyncValidationIsFinishedPromise = Promise.all(asyncValidatedSubValues).then((flatValidatedValues) => {
const validationResult2 = flatValidatedValues.every((isValid) => isValid);
if (!validationResult2) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
error.constraints[type] = message;
if (metadata.context) {
if (!error.contexts) {
error.contexts = {};
}
error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
}
}
});
this.awaitingPromises.push(asyncValidationIsFinishedPromise);
return;
}
const validationResult = validatedSubValues.every((isValid) => isValid);
if (!validationResult) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
error.constraints[type] = message;
}
});
});
}
nestedValidations(value, metadatas, error) {
if (value === undefined) {
return;
}
metadatas.forEach((metadata) => {
if (metadata.type !== ValidationTypes_1.ValidationTypes.NESTED_VALIDATION && metadata.type !== ValidationTypes_1.ValidationTypes.PROMISE_VALIDATION) {
return;
} else if (this.validatorOptions && this.validatorOptions.stopAtFirstError && Object.keys(error.constraints || {}).length > 0) {
return;
}
if (Array.isArray(value) || value instanceof Set || value instanceof Map) {
const arrayLikeValue = value instanceof Set ? Array.from(value) : value;
arrayLikeValue.forEach((subValue, index) => {
this.performValidations(value, subValue, index.toString(), [], metadatas, error.children);
});
} else if (value instanceof Object) {
const targetSchema = typeof metadata.target === "string" ? metadata.target : metadata.target.name;
this.execute(value, targetSchema, error.children);
} else {
const [type, message] = this.createValidationError(metadata.target, value, metadata);
error.constraints[type] = message;
}
});
}
mapContexts(object, value, metadatas, error) {
return metadatas.forEach((metadata) => {
if (metadata.context) {
let customConstraint;
if (metadata.type === ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION) {
const customConstraints = this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls);
customConstraint = customConstraints[0];
}
const type = this.getConstraintType(metadata, customConstraint);
if (error.constraints[type]) {
if (!error.contexts) {
error.contexts = {};
}
error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
}
}
});
}
createValidationError(object, value, metadata, customValidatorMetadata) {
const targetName = object.constructor ? object.constructor.name : undefined;
const type = this.getConstraintType(metadata, customValidatorMetadata);
const validationArguments = {
targetName,
property: metadata.propertyName,
object,
value,
constraints: metadata.constraints
};
let message = metadata.message || "";
if (!metadata.message && (!this.validatorOptions || this.validatorOptions && !this.validatorOptions.dismissDefaultMessages)) {
if (customValidatorMetadata && customValidatorMetadata.instance.defaultMessage instanceof Function) {
message = customValidatorMetadata.instance.defaultMessage(validationArguments);
}
}
const messageString = ValidationUtils_1.ValidationUtils.replaceMessageSpecialTokens(message, validationArguments);
return [type, messageString];
}
getConstraintType(metadata, customValidatorMetadata) {
const type = customValidatorMetadata && customValidatorMetadata.name ? customValidatorMetadata.name : metadata.type;
return type;
}
}
exports.ValidationExecutor = ValidationExecutor;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/validation/Validator.js
var require_Validator = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Validator = undefined;
var ValidationExecutor_1 = require_ValidationExecutor();
class Validator {
validate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
return this.coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions);
}
async validateOrReject(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
const errors = await this.coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions);
if (errors.length)
return Promise.reject(errors);
}
validateSync(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions : objectOrSchemaName;
const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions;
const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName : undefined;
const executor = new ValidationExecutor_1.ValidationExecutor(this, options);
executor.ignoreAsyncValidations = true;
const validationErrors = [];
executor.execute(object, schema, validationErrors);
return executor.stripEmptyErrors(validationErrors);
}
coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions : objectOrSchemaName;
const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions;
const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName : undefined;
const executor = new ValidationExecutor_1.ValidationExecutor(this, options);
const validationErrors = [];
executor.execute(object, schema, validationErrors);
return Promise.all(executor.awaitingPromises).then(() => {
return executor.stripEmptyErrors(validationErrors);
});
}
}
exports.Validator = Validator;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/container.js
var require_container = __commonJS((exports) => {
var useContainer = function(iocContainer, options) {
userContainer = iocContainer;
userContainerOptions = options;
};
var getFromContainer = function(someClass) {
if (userContainer) {
try {
const instance = userContainer.get(someClass);
if (instance)
return instance;
if (!userContainerOptions || !userContainerOptions.fallback)
return instance;
} catch (error) {
if (!userContainerOptions || !userContainerOptions.fallbackOnErrors)
throw error;
}
}
return defaultContainer.get(someClass);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getFromContainer = exports.useContainer = undefined;
var defaultContainer = new class {
constructor() {
this.instances = [];
}
get(someClass) {
let instance = this.instances.find((instance2) => instance2.type === someClass);
if (!instance) {
instance = { type: someClass, object: new someClass };
this.instances.push(instance);
}
return instance.object;
}
};
var userContainer;
var userContainerOptions;
exports.useContainer = useContainer;
exports.getFromContainer = getFromContainer;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/Allow.js
var require_Allow = __commonJS((exports) => {
var Allow = function(validationOptions) {
return function(object, propertyName) {
const args = {
type: ValidationTypes_1.ValidationTypes.WHITELIST,
target: object.constructor,
propertyName,
validationOptions
};
(0, MetadataStorage_1.getMetadataStorage)().addValidationMetadata(new ValidationMetadata_1.ValidationMetadata(args));
};
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Allow = undefined;
var ValidationTypes_1 = require_ValidationTypes();
var ValidationMetadata_1 = require_ValidationMetadata();
var MetadataStorage_1 = require_MetadataStorage();
exports.Allow = Allow;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/metadata/ConstraintMetadata.js
var require_ConstraintMetadata = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConstraintMetadata = undefined;
var container_1 = require_container();
class ConstraintMetadata {
constructor(target, name, async = false) {
this.target = target;
this.name = name;
this.async = async;
}
get instance() {
return (0, container_1.getFromContainer)(this.target);
}
}
exports.ConstraintMetadata = ConstraintMetadata;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/register-decorator.js
var require_register_decorator = __commonJS((exports) => {
var registerDecorator = function(options) {
let constraintCls;
if (options.validator instanceof Function) {
constraintCls = options.validator;
const constraintClasses = (0, container_1.getFromContainer)(MetadataStorage_1.MetadataStorage).getTargetValidatorConstraints(options.validator);
if (constraintClasses.length > 1) {
throw `More than one implementation of ValidatorConstraintInterface found for validator on: ${options.target.name}:${options.propertyName}`;
}
} else {
const validator = options.validator;
constraintCls = class CustomConstraint {
validate(value, validationArguments) {
return validator.validate(value, validationArguments);
}
defaultMessage(validationArguments) {
if (validator.defaultMessage) {
return validator.defaultMessage(validationArguments);
}
return "";
}
};
(0, MetadataStorage_1.getMetadataStorage)().addConstraintMetadata(new ConstraintMetadata_1.ConstraintMetadata(constraintCls, options.name, options.async));
}
const validationMetadataArgs = {
type: options.name && ValidationTypes_1.ValidationTypes.isValid(options.name) ? options.name : ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION,
name: options.name,
target: options.target,
propertyName: options.propertyName,
validationOptions: options.options,
constraintCls,
constraints: options.constraints
};
(0, MetadataStorage_1.getMetadataStorage)().addValidationMetadata(new ValidationMetadata_1.ValidationMetadata(validationMetadataArgs));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerDecorator = undefined;
var ConstraintMetadata_1 = require_ConstraintMetadata();
var ValidationMetadata_1 = require_ValidationMetadata();
var ValidationTypes_1 = require_ValidationTypes();
var container_1 = require_container();
var MetadataStorage_1 = require_MetadataStorage();
exports.registerDecorator = registerDecorator;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/ValidateBy.js
var require_ValidateBy = __commonJS((exports) => {
var buildMessage = function(impl, validationOptions) {
return (validationArguments) => {
const eachPrefix = validationOptions && validationOptions.each ? "each value in " : "";
return impl(eachPrefix, validationArguments);
};
};
var ValidateBy = function(options, validationOptions) {
return function(object, propertyName) {
(0, register_decorator_1.registerDecorator)({
name: options.name,
target: object.constructor,
propertyName,
options: validationOptions,
constraints: options.constraints,
validator: options.validator
});
};
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidateBy = exports.buildMessage = undefined;
var register_decorator_1 = require_register_decorator();
exports.buildMessage = buildMessage;
exports.ValidateBy = ValidateBy;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/IsDefined.js
var require_IsDefined = __commonJS((exports) => {
var isDefined = function(value) {
return value !== undefined && value !== null;
};
var IsDefined = function(validationOptions) {
return (0, ValidateBy_1.ValidateBy)({
name: exports.IS_DEFINED,
validator: {
validate: (value) => isDefined(value),
defaultMessage: (0, ValidateBy_1.buildMessage)((eachPrefix) => eachPrefix + "$property should not be null or undefined", validationOptions)
}
}, validationOptions);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.IsDefined = exports.isDefined = exports.IS_DEFINED = undefined;
var ValidateBy_1 = require_ValidateBy();
var ValidationTypes_1 = require_ValidationTypes();
exports.IS_DEFINED = ValidationTypes_1.ValidationTypes.IS_DEFINED;
exports.isDefined = isDefined;
exports.IsDefined = IsDefined;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/IsOptional.js
var require_IsOptional = __commonJS((exports) => {
var IsOptional = function(validationOptions) {
return function(object, propertyName) {
const args = {
type: ValidationTypes_1.ValidationTypes.CONDITIONAL_VALIDATION,
target: object.constructor,
propertyName,
constraints: [
(object2, value) => {
return object2[propertyName] !== null && object2[propertyName] !== undefined;
}
],
validationOptions
};
(0, MetadataStorage_1.getMetadataStorage)().addValidationMetadata(new ValidationMetadata_1.ValidationMetadata(args));
};
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.IsOptional = undefined;
var ValidationTypes_1 = require_ValidationTypes();
var ValidationMetadata_1 = require_ValidationMetadata();
var MetadataStorage_1 = require_MetadataStorage();
exports.IsOptional = IsOptional;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/Validate.js
var require_Validate = __commonJS((exports) => {
var ValidatorConstraint = function(options) {
return function(target) {
const isAsync = options && options.async;
let name = options && options.name ? options.name : "";
if (!name) {
name = target.name;
if (!name)
name = name.replace(/\.?([A-Z]+)/g, (x, y) => "_" + y.toLowerCase()).replace(/^_/, "");
}
const metadata = new ConstraintMetadata_1.ConstraintMetadata(target, name, isAsync);
(0, MetadataStorage_1.getMetadataStorage)().addConstraintMetadata(metadata);
};
};
var Validate = function(constraintClass, constraintsOrValidationOptions, maybeValidationOptions) {
return function(object, propertyName) {
const args = {
type: ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION,
target: object.constructor,
propertyName,
constraintCls: constraintClass,
constraints: Array.isArray(constraintsOrValidationOptions) ? constraintsOrValidationOptions : undefined,
validationOptions: !Array.isArray(constraintsOrValidationOptions) ? constraintsOrValidationOptions : maybeValidationOptions
};
(0, MetadataStorage_1.getMetadataStorage)().addValidationMetadata(new ValidationMetadata_1.ValidationMetadata(args));
};
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Validate = exports.ValidatorConstraint = undefined;
var ValidationMetadata_1 = require_ValidationMetadata();
var MetadataStorage_1 = require_MetadataStorage();
var ValidationTypes_1 = require_ValidationTypes();
var ConstraintMetadata_1 = require_ConstraintMetadata();
exports.ValidatorConstraint = ValidatorConstraint;
exports.Validate = Validate;
});
// /export/htdocs/p/framework/node_modules/class-validator/cjs/decorator/common/ValidateIf.js
var require_ValidateIf = __commonJS((exports) =>