dausdaskreuz/mcf-objects
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Initial commit. Compile package code

Browse source
This commit is contained in:
dgarcia 2020-03-16 23:25:54 +01:00
commit 4f73f1802e
18 changed files with 9605 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

235
src/index.js Normal file
View file

@ -0,0 +1,235 @@
// --== OBJECTS LIBRARY ==--
// ========================================
class MCF_Type {
constructor(definition){
this.definition = definition;
this.validations = {};
}
setValue(value){
this.validate(value);
this.value = value;
}
getValue(){
return this.value;
}
validate(value){
for (let validation in this.validations){
this.validations[validation](value, this.definition);
}
}
}
class MCF_String extends MCF_Type {
constructor(definition){
super(definition);
this.addValidations();
}
addValidations(){
this.validations.type = function(value) {
if (typeof (value) !== "string") {
throw new Error(`MCF_String creation: the type of ${value} isn't "string"`);
}
};
for (let param in this.definition){
switch (param) {
case 'maxLength':
this.validations.maxLength = function(value, definition){
if (value.length > definition.maxLength){
throw new Error(`MCF_String creation: the length of the string "${value}" is higher than the maximum defined: ${definition.maxLength}`);
}
};
break;
case 'minLength':
this.validations.minLength = function(value, definition){
if (value.length < definition.minLength){
throw new Error(`MCF_String creation: the length of the string "${value}" is lower than the minimum defined: ${definition.minLength}`);
}
};
break;
}
}
}
}
class MCF_Number extends MCF_Type{
constructor(definition){
super(definition);
this.addValidations();
}
addValidations(){
this.validations.type = function(value) {
if (typeof (value) !== "number") {
throw new Error(`MCF_Number creation: the type of the value ${value} isn't "number"`);
}
};
for (let param in this.definition){
switch (param) {
case 'max':
this.validations.max = function(value, definition){
if (value > definition.max){
throw new Error(`MCF_Number creation: the value ${value} is higher than the maximum defined: ${definition.maxLength}`);
}
};
break;
case 'min':
this.validations.min = function(value, definition){
if (value < definition.min){
throw new Error(`MCF_Number creation: the value ${value} is lower than the minimum defined: ${definition.minLength}`);
}
};
break;
}
}
}
}
class MCF_Boolean extends MCF_Type{
constructor(definition){
super(definition);
this.addValidations();
}
addValidations(){
this.validations.type = function(value) {
if (typeof (value) !== "boolean") {
throw new Error(`MCF_Boolean creation: the type of the value ${value} isn't "boolean"`);
}
};
}
}
class MCF_Array extends MCF_Type {
constructor(definition){
super(definition);
this.addValidations();
}
addValidations(){
this.validations.type = function(value) {
if (!Array.isArray(value)) {
throw new Error(`MCF_Array creation: the type of ${value} isn't "array"`);
}
};
for (let param in this.definition){
switch (param) {
case 'maxLength':
this.validations.maxLength = function(value, definition){
if (value.length > definition.maxLength){
throw new Error(`MCF_Array creation: the length of the array "${value}" is higher than the maximum defined: ${definition.maxLength}`);
}
};
break;
case 'minLength':
this.validations.minLength = function(value, definition){
if (value.length < definition.minLength){
throw new Error(`MCF_Array creation: the length of the array "${value}" is lower than the minimum defined: ${definition.minLength}`);
}
};
break;
}
}
}
}
class MCF_Enum extends MCF_Type{
constructor(definition){
super(definition);
this.addValidations();
}
addValidations(){
this.validations.isAvailable = function(value, definition){
const valueIsAvailable = definition.availableValues.reduce(function(isAvailable, availableValue){
if (value === availableValue) return true;
return isAvailable;
}, false);
if (!valueIsAvailable){
throw new Error(`MCF_Enum creation: the value "${value}" isn't one of the next values, included in the field definition: ${definition.availableValues.toString()}`);
}
}
}
}
class MCF_TypeFactory {
static buildDefinedObject(definedObject) {
const objectDefinition = definedObject.getDefinition();
let fields = objectDefinition.fields;
let dictionary = {};
for (let field in fields) {
switch (fields[field]['TYPE']) {
case 'string':
dictionary[field] = new MCF_String(fields[field]);
break;
case 'number':
dictionary[field] = new MCF_Number(fields[field]);
break;
case 'boolean':
dictionary[field] = new MCF_Boolean(fields[field]);
break;
case 'enum':
dictionary[field] = new MCF_Enum(fields[field]);
break;
case 'array':
dictionary[field] = new MCF_Array(fields[field]);
break;
}
}
return dictionary;
}
}
class MCF_DefinedObject {
constructor(definition){
this.definition = definition;
this.validations = {};
this.fields = MCF_TypeFactory.buildDefinedObject(this);
this.setValue(definition.value)
}
getDefinition(){
return this.definition;
}
getValue(){
let value = {};
for (let field in this.fields){
value[field] = this.fields[field].value;
}
return value;
}
setValue(value){
for (let field in this.definition.fields){
if (value[field] === undefined || value === null){
if (this.definition.fields[field].required === true){
throw new Error(`The field ${field} is required`);
}
if (this.definition.fields[field].defaultValue !== undefined){
value[field] = this.definition.fields[field].defaultValue;
}
if (this.definition.fields[field].null === false){
throw new Error(`The field ${field} can't be undefined`);
}
}
}
for (let field in value){
if (value[field] === undefined){
this.fields[field].value = undefined;
} else {
this.fields[field].setValue(value[field]);
}
}
}
setPropertiesValue(value){
for (let field in value){
this.fields[field].setValue(value[field]);
}
}
}
export {MCF_DefinedObject as definedObject};