Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
megadb - npm Package Compare versions
Comparing version 2.7.0 to 2.8.0
970
index.js
@@ -1,10 +0,1 @@ | ||
| const fs = require('graceful-fs'), | ||
| path = require('path'), | ||
| mkdirp = require('mkdirp'); | ||
| let global_object = new Object() //objeto interno, no eliminar! | ||
| /* | ||
@@ -22,959 +13,4 @@ | ||
| module.exports = { | ||
| crearDB | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| /* | ||
| Funciones internas: | ||
| - readJSON | ||
| - saveJSON | ||
| - check_path_object | ||
| - ErrorDesc | ||
| - get_data | ||
| - is_float | ||
| - is_num | ||
| */ | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function is_float(n) { | ||
| return typeof(n, "Number") && !!(n % 1) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function is_num(n) { | ||
| return !!parseInt(n) == false && parseInt(n) != 0 ? false : true | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function readJSON(path_file_name) { | ||
| if(!fs.existsSync(path_file_name)) throw new Error(`[ERROR] El archivo ${path_file_name} no existe.`) | ||
| var obj_data; | ||
| try{ | ||
| let get_data = fs.readFileSync(path_file_name, 'utf8') | ||
| obj_data = JSON.parse(get_data) | ||
| } | ||
| catch(error) { | ||
| throw new Error(`[ERROR] Ocurrio un problema al tratar de leer los datos del archivo ${path_file_name}, error: ${error}`) | ||
| } | ||
| return obj_data | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function saveJSON(path_file_name, new_object) { | ||
| if(!fs.existsSync(path_file_name)) throw new Error(`[ERROR] El archivo ${path_file_name} no existe.`) | ||
| try{ | ||
| fs.writeFileSync(path_file_name, JSON.stringify(new_object, null, 2), 'utf8') | ||
| return true | ||
| } | ||
| catch(error) { | ||
| throw new Error(`[ERROR] Ocurrio un error al tratar de guardar los datos en el archivo ${path_file_name}, error: ${error}`) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function check_path_object(path_object, split_object) { | ||
| if(!path_object) throw new Error(`[ERROR] El nombre de la clave no fue especificado`) | ||
| if(typeof path_object != "string") throw new Error(`[ERROR] El nombre de la clave debe ser un string`) | ||
| if(path_object.includes(`${split_object}${split_object}`)) throw new Error(`[ERROR] El nombre de la clave no debe de contener el signo ${split_object} seguido de otro.`) | ||
| if(path_object.startsWith(split_object) || path_object.endsWith(split_object)) throw new Error(`[ERROR] El nombre de la clave no debe empezar ni terminar con un ${split_object}`) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function ErrorDesc(type_error, description) { | ||
| error_object = { | ||
| type: type_error, | ||
| mensaje: description | ||
| } | ||
| return error_object | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function get_path(sub_directory) { | ||
| let directorio = path.dirname(require.main.filename).split("/"); | ||
| for(var x = 0; x < directorio.length; x++) { | ||
| if(fs.existsSync(`${directorio.join("/")}/node_modules`)) { | ||
| if(!fs.existsSync(`${directorio.join("/")}/mega_databases`)) { | ||
| mkdirp(`${directorio.join("/")}/mega_databases`, function(err) { | ||
| if(err) throw new Error(`[ERROR] No se pudo crear la carpeta mega_databases donde se almacenaran las base de datos, error: ${err}`) | ||
| console.log(`[CREANDO DIRECTORIO] Acaba de crearse la carpeta mega_databases, en esta carpeta ${sub_directory != false ? "se creara tu sub directorio" : "se almacenaran tus base de datos"}.`) | ||
| }) | ||
| } | ||
| if(sub_directory) { | ||
| if(!fs.existsSync(`${directorio.join("/")}/mega_databases/${sub_directory}`)) { | ||
| mkdirp(`${directorio.join("/")}/mega_databases/${sub_directory}`, function(err) { | ||
| if(err) throw new Error(`[ERROR] No se pudo crear el sub directorio ${sub_directory}, error: ${err}`) | ||
| console.log(`[CREANDO SUB DIRECTORIO] Acaba de crearse el sub directorio ${sub_directory}, en esta carpeta se almacenaran tus base de datos.`) | ||
| }) | ||
| } | ||
| } | ||
| path_main_file = sub_directory != false ? `${directorio.join("/")}/mega_databases/${sub_directory}` : `${directorio.join("/")}/mega_databases` | ||
| return path_main_file | ||
| } | ||
| directorio = directorio.slice(0, -1) | ||
| } | ||
| return false | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function crearDB(database_name, sub_directory = false) { //constuctor | ||
| if(!database_name) throw new Error(`[ERROR] Necesitas colocar el nombre de la base de datos`) | ||
| if(typeof database_name != "string") throw new Error(`[ERROR] El nombre de la base de datos ${database_name} debe ser un string`) | ||
| if(database_name.includes("/")) throw new Error(`[ERROR] El nombre de la base de datos ${database_name} no debes contener el simbolo de barra ascendente: /`) | ||
| database_name = database_name.trim() | ||
| if(database_name.length <= 0) throw new Error(`[ERROR] Necesitas colocar un nombre a la base de datos`) | ||
| if(sub_directory) { | ||
| if(typeof sub_directory != "string") throw new Error(`[ERROR] El nombre del sub directorio ${database_name} debe ser un string`) | ||
| if(sub_directory.includes("/")) throw new Error(`[ERROR] El nombre del sub directorio ${sub_directory} no debe contener el simbolo de barra ascendente: /`) | ||
| sub_directory = sub_directory.trim() | ||
| if(sub_directory.length <= 0) throw new Error(`[ERROR] Necesitas colocar un nombre al sub directorio`) | ||
| } | ||
| this.database_name = database_name | ||
| this.object_id = sub_directory ? `${sub_directory}/${database_name}` : database_name | ||
| this.path_main_carpet = get_path(sub_directory) | ||
| //En caso de que no encuentre la ruta correcta | ||
| if(this.path_main_carpet == false) throw new Error(`[ERROR] Ocurrio un problema obteniendo la ruta de la base de datos, asegurate que tu proyecto tenga la carpeta node_modules`) | ||
| this.path_file_name = `${this.path_main_carpet}/${database_name}.json` | ||
| if(!fs.existsSync(this.path_file_name)) { | ||
| fs.writeFileSync(this.path_file_name, JSON.stringify({}, null, 2), { flag: 'wx' }, function(err) { | ||
| if(err) throw new Error(`[ERROR] No se pudo crear la base de datos ${database_name}, error: ${err}`) | ||
| }); | ||
| } | ||
| this.preprare_db = function(path_file_name, object_id) { | ||
| if(!global_object[object_id]) { | ||
| global_object[object_id] = readJSON(path_file_name) | ||
| return | ||
| } | ||
| return | ||
| }(this.path_file_name, this.object_id) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| /* | ||
| constructor: | ||
| - crearDB | ||
| Metodos: | ||
| - existeDB | ||
| - establecer | ||
| - obtener | ||
| - tiene | ||
| - eliminar | ||
| - purgeall | ||
| - sumar | ||
| - restar | ||
| - push | ||
| - extract | ||
| - datos | ||
| - ordenar | ||
| - random | ||
| - convert_megadtbs | ||
| - keys | ||
| - values | ||
| - size | ||
| - find | ||
| - map | ||
| - filter | ||
| */ | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function existeDB(database_name) { //retorna true o false | ||
| if(!database_name) throw new Error(`[ERROR] El nombre de la base de datos no fue especificado`) | ||
| if(typeof database_name != "string") throw new Error(`[ERROR] El nombre de la base de datos debe ser un string`) | ||
| if(!fs.existsSync(`${this.path_main_carpet}/${database_name}.json`)) return false | ||
| return true | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function establecer(clave, valor, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| if(!valor && valor != 0) throw new Error(`[ERROR] El valor no fue especificado`) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(x == split_object.length-1) { | ||
| object_data[key] = valor | ||
| break | ||
| } | ||
| if(typeof object_data[key] == "undefined") { | ||
| object_data = object_data[key] = {} | ||
| continue | ||
| } | ||
| //con esto evitamos el bug del type {} == [] | ||
| object_data = (Array.isArray(object_data[key]) || typeof object_data[key] != "object") ? object_data[key] = {} : object_data[key] | ||
| } | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return Promise.resolve(global_object[this.object_id]) | ||
| } | ||
| return Promise.reject(ErrorDesc("DATABASE NO EXISTENTE", `[establecer] La base de datos ${this.database_name} no existe: ${this.path_main_file}`)) //tal vez ocurre algun error ?) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function tiene(clave, split_object) { //retorna true o false | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| return true | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return false | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function obtener(clave, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| return Promise.resolve(object_data[key]) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[obtener] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function eliminar(clave, split_object) { //retorna true o false | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| delete object_data[key] | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return true | ||
| } | ||
| return false //tal vez ocurre algun error ?) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return false | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function purgeall() { //retorna true o false | ||
| var object_data = global_object[this.object_id] | ||
| global_object[this.object_id] = {} | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return true | ||
| } | ||
| return false | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function sumar(clave, number, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| if(!number && number != 0) throw new Error(`[ERROR] Necesitas colocar el valor(numero)`) | ||
| if(!is_num(number)) throw new Error(`[ERROR] El valor debe ser un numero`) | ||
| number = is_float(number) ? parseFloat(number) : parseInt(number) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(!is_num(object_data[key])) return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[sumar] El valor de la propiedad ${key} no es un numero, base de datos: ${this.database_name}`)) | ||
| object_data[key] = (is_float(object_data[key]) ? parseFloat(object_data[key]) : parseInt(object_data[key])) + number | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return Promise.resolve(object_data[key]) | ||
| } | ||
| return Promise.reject(ErrorDesc("DATABASE NO EXISTENTE", `[sumar] La base de datos ${this.database_name} no existe: ${this.path_main_file}`)) //tal vez ocurre algun error ?) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[sumar] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function restar(clave, number, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| check_path_object(clave, split_object) | ||
| if(!number && number != 0) throw new Error(`[ERROR] Necesitas colocar el valor(numero)`) | ||
| if(!is_num(number)) throw new Error(`[ERROR] El valor debe ser un numero`) | ||
| number = is_float(number) ? parseFloat(number) : parseInt(number) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(!is_num(object_data[key])) return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[restar] El valor de la propiedad ${key} no es un numero, base de datos: ${this.database_name}`)) | ||
| object_data[key] = (is_float(object_data[key]) ? parseFloat(object_data[key]) : parseInt(object_data[key])) - number | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return Promise.resolve(object_data[key]) | ||
| } | ||
| return Promise.reject(ErrorDesc("DATABASE NO EXISTENTE", `[restar] La base de datos ${this.database_name} no existe: ${this.path_main_file}`)) //tal vez ocurre algun error ?) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[restar] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function push(clave, valor, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string.`) | ||
| check_path_object(clave, split_object) | ||
| if(!valor && valor != 0) throw new Error(`[ERROR] El valor no fue especificado`) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(!Array.isArray(object_data[key])) return Promise.reject(ErrorDesc("ARRAY NO EXISTENTE", `[push] El valor de la propiedad ${key} no es un array, base de datos: ${this.database_name}`)) | ||
| object_data[key].unshift(valor) | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return Promise.resolve(object_data[key]) | ||
| } | ||
| return Promise.reject(ErrorDesc("DATABASE NO EXISTENTE", `[push] La base de datos ${this.database_name} no existe: ${this.path_main_file}`)) //tal vez ocurre algun error ?) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[push] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function extract(clave, valor, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string.`) | ||
| check_path_object(clave, split_object) | ||
| if(!valor && valor != 0) throw new Error(`[ERROR] El valor no fue especificado`) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(!Array.isArray(object_data[key])) return Promise.reject(ErrorDesc("ARRAY NO EXISTENTE", `[extract] El valor de la propiedad ${key} no es un array, base de datos: ${this.database_name}`)) | ||
| if(!object_data[key].includes(valor)) return Promise.reject(ErrorDesc("ITEM NO EXISTENTE", `[extract] El item ${valor} no existe en el array ${key}, base de datos: ${this.database_name}`)) | ||
| object_data[key].splice(object_data[key].indexOf(valor), 1) | ||
| let save_data = saveJSON(this.path_file_name, global_object[this.object_id]) | ||
| if(save_data) { | ||
| return Promise.resolve(object_data[key]) | ||
| } | ||
| return Promise.reject(ErrorDesc("DATABASE NO EXISTENTE", `[extract] La base de datos ${this.database_name} no existe: ${this.path_main_file}`)) //tal vez ocurre algun error ?) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[extract] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function datos() { //retorna promesa | ||
| return Promise.resolve(global_object[this.object_id]) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function ordenar(clave, valor, split_object) { //tipos: (false, false) => (false, path_object) => (path_object, false) => (path_object, path_object) [retorna promesa con un array] | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string.`) | ||
| if(!clave && clave != false) throw new Error("[ERROR] El nombre de la clave no fue especificado") | ||
| if(clave != false && typeof clave != "string") throw new Error("[ERROR] Formato invalido, la clave debe de ser un string o false en caso de que la clave no sea un objecto con propiedades") | ||
| if(!valor && valor != false && valor != 0) throw new Error("[ERROR] El valor no fue especificado") | ||
| let final_array = [] | ||
| if(clave == false) { | ||
| //si la clave es false | ||
| if(valor == false) { | ||
| //si la clave y valor son false | ||
| if(Object.keys(global_object[this.object_id]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[ordenar] Actualmente no hay ninguna propiedad, base de datos: ${this.database_name}`)) | ||
| for(var key in global_object[this.object_id]) { | ||
| if(typeof global_object[this.object_id][key] != "number") return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[ordenar] El valor de la propiedad ${key} no es un numero, base de datos: ${this.database_name}`)) | ||
| final_array.push({clave: key, valor: global_object[this.object_id][key]}) | ||
| } | ||
| final_array.sort(function (a,b) { | ||
| return b.valor - a.valor | ||
| }) | ||
| return Promise.resolve(final_array) | ||
| } | ||
| //si la clave es false y el valor es un string (path object) | ||
| if(typeof valor != "string") throw new Error("[ERROR] Formato invalido, el valor debe ser un string o false en caso de que el valor no sea un objecto con propiedades") | ||
| if(valor.includes(`${split_object}${split_object}`)) throw new Error(`[ERROR] El nombre del valor no debe de contener el signo ${split_object} seguido de otro`) | ||
| if(valor.startsWith(split_object) || valor.endsWith(split_object)) throw new Error(`[ERROR] El nombre del valor no debe empezar ni terminar con un ${split_object}`) | ||
| let properties = valor.split(split_object) | ||
| for(var key1 in global_object[this.object_id]) { | ||
| var object_data = global_object[this.object_id][key1] | ||
| for(var x in properties) { | ||
| var index = properties[x] | ||
| if(typeof object_data[index] != "undefined") { | ||
| if(x == properties.length-1) { | ||
| if(typeof object_data[index] != "number") return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[ordenar] El valor de la propiedad ${index} no es un numero, base de datos: ${this.database_name}`)) | ||
| final_array.push({clave: key1, valor: object_data}) | ||
| } | ||
| object_data = object_data[index] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[ordenar] No se encontro la propiedad ${index}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| final_array.sort(function (a,b) { | ||
| return b.valor[properties[properties.length - 1]] - a.valor[properties[properties.length - 1]] | ||
| }) | ||
| return Promise.resolve(final_array) | ||
| } | ||
| if(valor == false) { | ||
| //si la clave es un string (path object) y el valor es false | ||
| check_path_object(clave, split_object) | ||
| let properties = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in properties) { | ||
| var index = properties[x] | ||
| if(typeof object_data[index] != "undefined") { | ||
| if(x == properties.length-1) { | ||
| for(var key in object_data[index]) { | ||
| if(typeof object_data[index][key] != "undefined") { | ||
| if(typeof object_data[index][key] != "number") return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[ordenar] El valor de la propiedad ${key} no es un numero, base de datos: ${this.database_name}`)) | ||
| final_array.push({clave: key, valor: object_data[index][key]}) | ||
| } | ||
| } | ||
| } | ||
| object_data = object_data[index] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[ordenar] No se encontro la propiedad ${index}, base de datos: ${this.database_name}`)) | ||
| } | ||
| final_array.sort(function (a,b) { | ||
| return b.valor - a.valor | ||
| }) | ||
| return Promise.resolve(final_array) | ||
| } | ||
| //Si la clave y valor son string (path object) | ||
| if(typeof valor != "string") throw new Error("[ERROR] Formato invalido, el valor debe ser un string o false en caso de que el valor no sea un objecto con propiedades") | ||
| if(valor.includes(`${split_object}${split_object}`)) throw new Error(`[ERROR] El nombre del valor no debe de contener el signo ${split_object} seguido de otro`) | ||
| if(valor.startsWith(split_object) || valor.endsWith(split_object)) throw new Error(`[ERROR] El nombre del valor no debe empezar ni terminar con un ${split_object}`) | ||
| check_path_object(clave, split_object) | ||
| check_path_object(valor, split_object) | ||
| let properties = clave.split(split_object) | ||
| let valuerties = valor.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x = 0; x < properties.length; x++) { | ||
| let index = properties[x] | ||
| if(typeof object_data[index] != "undefined") { | ||
| if(x == properties.length - 1) { | ||
| object_data = object_data[index] | ||
| for(var key in object_data) { | ||
| let propobject = object_data[key] | ||
| for(var y = 0; y < valuerties.length; y++) { | ||
| let index_2 = valuerties[y] | ||
| if(typeof propobject[index_2] != "undefined") { | ||
| if(y == valuerties.length - 1) { | ||
| if(typeof propobject[index_2] != "undefined") { | ||
| if(typeof propobject[index_2] != "number") return Promise.reject(ErrorDesc("NUMERO NO EXISTENTE", `[ordenar] El valor de la propiedad ${index_2} no es un numero, base de datos: ${this.database_name}`)) | ||
| final_array.push({clave: key, valor: propobject}) | ||
| } | ||
| } | ||
| propobject = propobject[index_2] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[ordenar] No se encontro la propiedad ${index_2}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| } | ||
| object_data = object_data[index] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[ordenar] No se encontro la propiedad ${index}, base de datos: ${this.database_name}`)) | ||
| } | ||
| final_array.sort(function (a,b) { | ||
| return b.valor[valuerties[valuerties.length - 1]] - a.valor[valuerties[valuerties.length - 1]] | ||
| }) | ||
| return Promise.resolve(final_array) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function random(clave, cantidad, split_object) { //retorna promesa con un array | ||
| if(clave !== false && typeof clave != "string") throw new Error(`[ERROR] La clave debe ser un string o false`) | ||
| let array = [] | ||
| if(!cantidad && cantidad != 0) throw new Error(`[ERROR] Necesitas colocar el valor(numero)`) | ||
| if(typeof cantidad != "number") throw new Error(`[ERROR] El valor debe ser un numero`) | ||
| cantidad = cantidad > 0 ? parseInt(cantidad) : 0 | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(clave === false) { | ||
| if(Object.keys(global_object[this.object_id]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[random] Actualmente no hay ninguna propiedad, base de datos: ${this.database_name}`)) | ||
| let keys = Object.keys(global_object[this.object_id]) | ||
| for (var i = 0; i < cantidad; i++) { | ||
| if(i >= keys.length) break | ||
| var random_number = parseInt((Math.random() * keys.length)); | ||
| do { | ||
| var existente = array.indexOf(keys[random_number]); | ||
| if(existente >= 0) { | ||
| random_number = parseInt((Math.random() * keys.length)); | ||
| } | ||
| else { | ||
| array.push(keys[random_number]); | ||
| existente = -2; | ||
| } | ||
| } | ||
| while(existente > -1); | ||
| } | ||
| let random_array = [] | ||
| if(array.length <= 0) return Promise.resolve(random_array) | ||
| array.map(r => random_array.push({clave: r, valor: global_object[this.object_id][r]})) | ||
| return Promise.resolve(random_array) | ||
| } | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(typeof object_data[key] != "object" || typeof object_data[key] == "object" && Array.isArray(object_data[key])) return Promise.reject(ErrorDesc("OBJETO NO EXISTENTE", `[random] El valor de la propiedad ${key} no es un objeto, base de datos: ${this.database_name}`)) | ||
| let keys = Object.keys(object_data[key]) | ||
| for (var i = 0; i < cantidad; i++) { | ||
| if(i >= keys.length) break | ||
| var random_number = parseInt((Math.random() * keys.length)); | ||
| do { | ||
| var existente = array.indexOf(keys[random_number]); | ||
| if(existente >= 0) { | ||
| random_number = parseInt((Math.random() * keys.length)); | ||
| } | ||
| else { | ||
| array.push(keys[random_number]); | ||
| existente = -2; | ||
| } | ||
| } | ||
| while(existente > -1); | ||
| } | ||
| let random_array = [] | ||
| if(array.length <= 0) return Promise.resolve(random_array) | ||
| array.map(r => random_array.push({clave: r, valor: object_data[key][r]})) | ||
| return Promise.resolve(random_array) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[random] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function convert_megadtbs() { //no retorna nada, solo es un adaptador | ||
| if(this.database_name != "mega_db") throw new Error(`[ERROR] El nombre de la base de datos del constructor crearDB debe ser "mega_db"`) | ||
| if(!fs.existsSync(`${this.path_main_carpet}/mega_db.json`)) throw new Error(`[ERROR] No se encontro el archivo mega_db.json en ${this.path_main_carpet}`) | ||
| let mega_dtbs = readJSON(this.path_file_name) | ||
| let successful_databases = [] | ||
| let invalid_databases = [] | ||
| if(Object.keys(mega_dtbs).length <= 0) throw new Error(`[ERROR] El archivo ${this.database_name} no contiene ninguna base de datos`) | ||
| for(var key in mega_dtbs) { | ||
| if(!mega_dtbs[key].hasOwnProperty("value")) throw new Error(`[ERROR] El archivo ${this.database_name} no contiene la estructura de la base de datos mega-dtbs`) | ||
| if(!fs.existsSync(`${this.path_main_carpet}/${key}.json`)) { | ||
| fs.writeFileSync(`${this.path_main_carpet}/${key}.json`, JSON.stringify(mega_dtbs[key].value, null, 2), { flag: 'wx' }, function(err) { | ||
| if(err) throw new Error(`[ERROR] No se pudo crear la base de datos ${database_name}, error: ${err}`) | ||
| }); | ||
| successful_databases.push(`${key}.json`) | ||
| continue | ||
| } | ||
| invalid_databases.push(`${key}`) | ||
| } | ||
| console.log(`[ADAPTACION FINALIZADA]`) | ||
| console.log(`[DATABASES ADAPTADAS CORRECTAMENTE] ${successful_databases.length > 0 ? successful_databases.join(" | ") : "Ninguno"}`) | ||
| console.log(`[DATABASES ERRONEAS] ${invalid_databases.length > 0 ? invalid_databases.join(" | ") : "Ninguno"}`) | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function keys(clave = false, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(clave === false) { | ||
| let keys = Object.keys(global_object[this.object_id]) | ||
| return Promise.resolve(keys) | ||
| } | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(typeof object_data[key] != "object" || Array.isArray(object_data[key])) return Promise.reject(ErrorDesc("OBJETO NO EXISTENTE", `[keys] El valor de la propiedad ${key} no es un objeto, base de datos: ${this.database_name}`)) | ||
| let keys_obj = Object.keys(object_data[key]) | ||
| return Promise.resolve(keys_obj) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[keys] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function values(clave = false, split_object) { //retorna promesa | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(clave === false) { | ||
| let values = Object.keys(global_object[this.object_id]).map(o => global_object[this.object_id][o]) | ||
| return Promise.resolve(values) | ||
| } | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| if(typeof object_data[key] != "object" || Array.isArray(object_data[key])) return Promise.reject(ErrorDesc("OBJETO NO EXISTENTE", `[values] El valor de la propiedad ${key} no es un objeto, base de datos: ${this.database_name}`)) | ||
| let values_obj = Object.keys(object_data[key]).map(o => object_data[key][o]) | ||
| return Promise.resolve(values_obj) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[values] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function size() { //retorna promesa | ||
| return Object.keys(global_object[this.object_id]).length | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function find(clave, callback, split_object) { //retorna valor | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)') | ||
| if(clave === false) { | ||
| if(Object.keys(global_object[this.object_id]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[find] Actualmente no hay ninguna propiedad, base de datos: ${this.database_name}`)) | ||
| for(var key in global_object[this.object_id]) { | ||
| if(callback(global_object[this.object_id][key], key)) return Promise.resolve(global_object[this.object_id][key]) | ||
| } | ||
| return Promise.resolve(undefined) | ||
| } | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| for(var key2 in object_data[key]) { | ||
| if(callback(object_data[key][key2], key2)) return Promise.resolve(object_data[key][key2]) | ||
| } | ||
| return Promise.resolve(undefined) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[find] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function filter(clave, callback, split_object) { //retorna un nuevo objeto con los elementos que cumplan la condicion del callback, similar al <array>.filter | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)') | ||
| let filter_array = {} | ||
| if(clave === false) { | ||
| if(Object.keys(global_object[this.object_id]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[filter] Actualmente no hay ninguna propiedad, base de datos: ${this.database_name}`)) | ||
| for(var key in global_object[this.object_id]) { | ||
| if(callback(global_object[this.object_id][key], key)) filter_array[key] = global_object[this.object_id][key] | ||
| } | ||
| if(Object.keys(filter_array).length <= 0) return Promise.resolve(undefined) | ||
| return Promise.resolve(filter_array) | ||
| } | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| for(var key2 in object_data[key]) { | ||
| if(callback(object_data[key][key2], key2)) filter_array[key2] = object_data[key][key2] | ||
| } | ||
| if(Object.keys(filter_array).length <= 0) return Promise.resolve(undefined) | ||
| return Promise.resolve(filter_array) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[filter] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| function map(clave, callback, split_object) { //retorna un array con los resultados que se especifico en el callback, similar al <array>.map | ||
| if(!split_object) split_object = "." | ||
| if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`) | ||
| if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)') | ||
| if(clave === false) { | ||
| if(Object.keys(global_object[this.object_id]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[map] Actualmente no hay ninguna propiedad, base de datos: ${this.database_name}`)) | ||
| let map_array = new Array() | ||
| for(var key in global_object[this.object_id]) map_array.push(callback(global_object[this.object_id][key], key)) | ||
| return Promise.resolve(map_array) | ||
| } | ||
| check_path_object(clave, split_object) | ||
| var split_object = clave.split(split_object) | ||
| var object_data = global_object[this.object_id] | ||
| for(var x in split_object) { | ||
| var key = split_object[x] | ||
| if(typeof object_data[key] != "undefined") { | ||
| if(x == split_object.length-1) { | ||
| let map_array = new Array() | ||
| for(var key2 in object_data[key]) map_array.push(callback(object_data[key][key2], key2)) | ||
| return Promise.resolve(map_array) | ||
| } | ||
| object_data = object_data[key] | ||
| continue | ||
| } | ||
| return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `[map] No se encontro la propiedad ${key}, base de datos: ${this.database_name}`)) | ||
| } | ||
| } | ||
| //--------------------------------------------------------------------------------------\\ | ||
| //---------------------------------------------------------------------------------------\\ | ||
| crearDB.prototype.existeDB = existeDB | ||
| crearDB.prototype.establecer = establecer | ||
| crearDB.prototype.tiene = tiene | ||
| crearDB.prototype.obtener = obtener | ||
| crearDB.prototype.eliminar = eliminar | ||
| crearDB.prototype.purgeall = purgeall | ||
| crearDB.prototype.sumar = sumar | ||
| crearDB.prototype.restar = restar | ||
| crearDB.prototype.push = push | ||
| crearDB.prototype.extract = extract | ||
| crearDB.prototype.datos = datos | ||
| crearDB.prototype.ordenar = ordenar | ||
| crearDB.prototype.random = random | ||
| crearDB.prototype.convert_megadtbs = convert_megadtbs | ||
| crearDB.prototype.keys = keys | ||
| crearDB.prototype.values = values | ||
| crearDB.prototype.size = size | ||
| crearDB.prototype.find = find | ||
| crearDB.prototype.filter = filter | ||
| crearDB.prototype.map = map | ||
| crearDB: require("./class/crearDB"), | ||
| memoDB: require("./class/memoDB") | ||
| } |
| { | ||
| "name": "megadb", | ||
| "version": "2.7.0", | ||
| "version": "2.8.0", | ||
| "description": "base de datos usando JSON", | ||
@@ -5,0 +5,0 @@ "main": "index.js", |
214
README.md
| ``` | ||
| megadb es una actualizacion de mi antiguo package llamado mega-dtbs (https://www.npmjs.com/package/mega-dtbs) | ||
| Este package es una actualizacion de mi antiguo package llamado mega-dtbs (https://www.npmjs.com/package/mega-dtbs) | ||
| megadb es un manejador de archivos JSON, contiene multiples metodos las cuales te facilitiaran las cosas y podras trabajar de una forma sencilla, persistente y eficaz. | ||
@@ -7,2 +8,3 @@ ``` | ||
| ``` | ||
| - Se creo una db en memoria (ver el constructor de memoDB) | ||
| - Se agrego nuevos metodos y parametros especiales. | ||
@@ -13,6 +15,5 @@ - Se actualizo absolutamente todo el codigo para una mejor legibilidad y funcionamiento. | ||
| - Errores descriptivos. | ||
| - Se arreglo un problema interno. | ||
| ``` | ||
| ## Importantehttps://discordapp.com/channels/@me | ||
| ## Importante | ||
| ``` | ||
@@ -24,2 +25,7 @@ - Se creara una carpeta llamada mega_databases en la carpeta principal de tu proyecto, no borres esta carpeta a menos que quieras borrar absolutamente todas tus base de datos. | ||
| v2.8.0 | ||
| * Se agrego el metodo some. | ||
| * Se agrego un alias en los metodos: establecer (set), obtener (get), tiene (has), eliminar (delete), sumar (add), restar (subtract), ordenar (sort) | ||
| * Se creo el constructor memoDB la cual hará que puedas hacer una db en memoria, ver el apartado de [memoDB](#memoDB) para mas informacion. | ||
| v2.7.0 | ||
@@ -52,2 +58,3 @@ * Se mejoró el metodo sumar y restar, ahora se podrá ingresar numeros en formato string, tambien se mejoró la descripcion de los errores. | ||
| * [crearDB](#crearDB) | ||
| * [memoDB](#memoDB) | ||
@@ -74,2 +81,3 @@ ## Metodos: | ||
| * [map](#map) | ||
| * [some](#some) | ||
| * [convert_megadtbs](#convert_megadtbs) | ||
@@ -148,2 +156,60 @@ | ||
| <a name="memoDB" /> | ||
| ### memoDB | ||
| El constructor memoDB te permitira crear una base de datos en memoria de forma eficiente. | ||
| Que quiere decir base de datos en memoria? | ||
| Practicamente los datos que agregues no se guardaran en un archivo ya que se mantendran en la memoria interna de este package, recuerda que los datos que agregues se perderan cada vez que tu proyecto/app se apague o reinicie. | ||
| Esto es perfecto para hacer cosas rapidas. | ||
| ```js | ||
| memoDB(nombre_db) | ||
| ``` | ||
| __Argumentos__ | ||
| 1. nombre_db: Nombre de la base de datos, en caso de que quieras obtener los datos de esta db en otro archivo, solo debes de colocar el mismo nombre. | ||
| __Recuerda__ | ||
| No habrá ningun problema si colocas el nombre de una base de datos que esta siendo usada en el constructor crearDB, ambas dbs guardaran datos por separado. | ||
| __Importante__ | ||
| Este constructor puede usar unicamente los siguientes metodos: | ||
| - establecer | ||
| - obtener | ||
| - tiene | ||
| - eliminar | ||
| - purgeall | ||
| - sumar | ||
| - restar | ||
| - push | ||
| - extract | ||
| - datos | ||
| - ordenar | ||
| - random | ||
| - keys | ||
| - values | ||
| - size | ||
| - find | ||
| - filter | ||
| - map | ||
| - some | ||
| __Ejemplos__ | ||
| ```js | ||
| //Ejemplo 1 | ||
| const db = require('megadb'); | ||
| let puntajes = new db.memoDB('niveles'); | ||
| /* | ||
| Esto hará que se cree la base de datos niveles en la memoria interna | ||
| */ | ||
| ``` | ||
| <a name="establecer" /> | ||
@@ -154,2 +220,5 @@ ### establecer | ||
| establecer(clave, valor, clave_split) | ||
| //[alias] | ||
| set(clave, valor, clave_split) | ||
| ``` | ||
@@ -233,2 +302,5 @@ | ||
| obtener(clave, clave_split) | ||
| //[alias] | ||
| get(clave, clave_split) | ||
| ``` | ||
@@ -269,2 +341,5 @@ | ||
| tiene(clave, clave_split) | ||
| //[alias] | ||
| has(clave, clave_split) | ||
| ``` | ||
@@ -302,2 +377,5 @@ | ||
| eliminar(clave, clave_split) | ||
| //[alias] | ||
| delete(clave, clave_split) | ||
| ``` | ||
@@ -509,2 +587,5 @@ | ||
| sumar(clave, valor, clave_split) | ||
| //[alias] | ||
| add(clave, valor, clave_split) | ||
| ``` | ||
@@ -577,2 +658,5 @@ | ||
| restar(clave, valor, clave_split) | ||
| //[alias] | ||
| subtract(clave, valor, clave_split) | ||
| ``` | ||
@@ -770,2 +854,5 @@ | ||
| ordenar(clave, valor, clave_split) | ||
| //[alias] | ||
| sort(clave, valor, clave_split) | ||
| ``` | ||
@@ -1714,2 +1801,123 @@ | ||
| <a name="some" /> | ||
| ### some | ||
| ```js | ||
| some(clave, callback(), clave_split) | ||
| ``` | ||
| Este metodo comprueba si al menos una propiedad del objeto(la base de datos) cumple con la condicion que se especificó en el callback. | ||
| Es similar al **Array.some** | ||
| __Argumentos__ | ||
| 1. clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objecto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) | ||
| Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos. | ||
| 2. callback(valor_actual, clave_actual): Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos: | ||
| ``` | ||
| valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento. | ||
| clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento. | ||
| ``` | ||
| 3. clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .) | ||
| __Retorna__ | ||
| Esto retornara true si la condicion del callback se cumple, de lo contrario retornara false. | ||
| __Error__ | ||
| En caso de que ocurra un error, esto regresara un objeto con el error descriptivo *(puedes obtenerlo con un .catch(error => ))* | ||
| [Click aqui para ver los tipos de errores](#Errores) | ||
| __Ejemplos__ | ||
| ```js | ||
| //ejemplo_1 | ||
| const db = require("megadb"); | ||
| let puntaje = new db.crearDB("puntajes") | ||
| puntaje.establecer('Mario', 2) | ||
| puntaje.establecer('Pedro', 4) | ||
| puntaje.establecer('Juan', 5) | ||
| puntaje.establecer('Jair', 6) | ||
| /* Estructura actual de la base de datos puntajes.json: | ||
| { | ||
| "Mario": 2, | ||
| "Pedro": 4, | ||
| "Juan": 5, | ||
| "Jair": 6 | ||
| } | ||
| */ | ||
| let verificar = puntaje.some(false, (v) => v == 6) | ||
| if(verificar) { | ||
| console.log("Un usuario tiene 6 puntos.") | ||
| } | ||
| else{ | ||
| console.log("Ningun usuario tiene 6 puntos.") | ||
| } | ||
| /*Esto da como resultado: | ||
| "Un usuario tiene 6 puntos" | ||
| */ | ||
| ///////////////////////////////////////////////////// | ||
| //ejemplo_2 | ||
| const db = require("megadb"); | ||
| let users_lb = new db.crearDB("userspt") | ||
| let usuarios = { | ||
| "user001": { | ||
| "nombre": "MegaStar", | ||
| "puntos": 10 | ||
| }, | ||
| "user002": { | ||
| "nombre": "Juan", | ||
| "puntos": 4 | ||
| }, | ||
| "user003": { | ||
| "nombre": "reDoM", | ||
| "puntos": 2 | ||
| } | ||
| } | ||
| users_lb.establecer('leaderboard', usuarios) | ||
| /* Estructura actual de la base de datos userspt.json: | ||
| { | ||
| "leaderboard": { | ||
| "user001": { | ||
| "nombre": "MegaStar", | ||
| "puntos": 10 | ||
| }, | ||
| "user002": { | ||
| "nombre": "Juan", | ||
| "puntos": 4 | ||
| }, | ||
| "user003": { | ||
| "nombre": "reDoM", | ||
| "puntos": 3 | ||
| } | ||
| } | ||
| } | ||
| */ | ||
| console.log(users_lb.some("leaderboard", (v) => v.nombre == "MegaStar")) // retorna true | ||
| console.log(users_lb.some("leaderboard", (v) => v.nombre == "MoDeR")) // retorna false | ||
| console.log(users_lb.some("leaderboard", (v) => v.puntos > 5)) // retorna true | ||
| ``` | ||
| <a name="convert_megadtbs" /> | ||
@@ -1716,0 +1924,0 @@ ### convert_megadtbs |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Filesystem access
Supply chain riskAccesses the file system, and could potentially read sensitive data.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by20.66%
117401
- Number of package files
- increased by575%
27
- Lines of code
- increased by36.04%
1057
- Number of lines in readme file
- increased by10.79%
2135
Worsened metrics
- Number of low supply chain risk alerts
- increased by300%
4
- Number of medium supply chain risk alerts
- increased byInfinity%
1
No dependency changes