Shinkdb NPM | npm.io

ese NPM lo hice par aquellas personas que no saben crear una base de dates real con MongoDB, o Mongoose. y necesitan de algun modo guardar dates semi-automaticamente. En Archivos JSON

Importante

Predeterminadamente se creará una carpeta llamada databases en la carpeta principal de tu proyecto (puedes cambiar el nombre de esta carpeta en el constructor) createDB. No borres dicha carpeta a menos que quieras borrar absolutamente todas tus base de dates.

Constructor:

createDB

Metodos:

set
size
get
has
delete
dates
push
extract
add
rem
keys
values
purgeall
sort
random
exiseDB
find
filter
map
some
setIndex
delIndex
findKey
partition

Instalacion:

npm install shinkdb --save

Ejemplo del requerimiento del package:

const db = require('shinkdb');

createDB(nombre_db, sub_directorio)

Este constructor te permite crear una base de dates.

Modo de uso

Este constructor tiene dos modos de uso:

Modo #1

Este modo es el que siempre se ha usado, aqui debes de especificar el nombre de la base de dates y el sub directorio(opcional).

En este modo por default la carpeta donde se almacenarán tus bases de dates será databases, y si esta carpeta no existe se creará automaticamente.

nombre_db: Nombre del archivo con el que se creara la base de dates, si el nombre de la base de datos que pusiste ya existia, lo que hara es devolver los dates existentes de esa db.
sub_directorio (opcional): Este argumento es opcional, es para especificar si quieres que la base de dates se guarde en un sub diréctorio dentro de la carpeta databases.

Ejemplo

//Ejemplo 1
const db = require('shinkdb');
let niveles = new db.createDB('niveles');
/*
Esto hará que se cree la base de dates niveles.json dentro de la carpeta databases

Estructura:

[–] node_modules
[+] databases
    - niveles.json

*/

//Ejemplo 2
const db = require('shinkdb');
let economia = new db.createDB('guild_1', 'economia_db');
/*
Esto hará que se cree un sub directorio llamado "economia_db" dentro de la carpeta databases, y dentro de este sub directorio se creará la base de dates guild_1.json

Estructura:

[–] node_modules
[+] databases
    [+] economia_db
        - guild_1.json
    - niveles.json
*/

Modo #2

Este modo te permite hacer lo mismo que el modo #1, la unica diferencia es que ahora puedes especificar el nombre de la carpeta donde se almacenaran tus bases de dates y tambien añadir la opcion de que tu base de dates no se llegue a reescribir rapidamente.

En este modo solo se puede hacer uso de un parametro la cual debe de contener un objeto con 3 propiedades:

nombre: Nombre del archivo con el que se creara la base de dates, si el nombre de la base de dates que pusiste ya existia, lo que hara es devolver los dates existentes de esa db, este parametro es obligatorio.
carpeta (opcional): Aqui deberas de colocar el nombre de la carpeta donde se guardaran tus bases de dates, si no colocas esta propiedad, por default será databases.
sub (opcional): Esto tambien es opcional, aqui puedes especificar si quieres que la base de dates se guarde en un sub diréctorio dentro de la carpeta que especificaste en la propiedad carpeta.
guardar_tiempo (opcional): Aqui deberas de colocar el tiempo (en segundos) que se deberá esperar para actualizar los dates en la base de dates, debe ser mayor a 4 segundos (usalo con precaucion).

Ejemplo

//Ejemplo 1
const db = require('shinkdb');
let niveles = new db.createDB({
  nombre: "levels",
  carpeta: "dates_niveles"
});
/*
Esto hará que se cree la base de dates levels.json dentro de la carpeta dates_niveles

Estructura:

[–] node_modules
[+] dates_niveles
    - levels.json

*/


//Ejemplo 2
const db = require('shinkdb');
let economia = new db.createDB({
  nombre: 'usuarios',
  carpeta: "economia_db",
  sub: "dinero",
  guardar_tiempo: 5
});
/*
Esto hará que se cree un sub directorio llamado "dinero" dentro de la carpeta economia_db, y dentro de este sub directorio se creará la base de dates usuarios.json

Estructura:

[–] node_modules
[+] dates_niveles
    - levels.json
[+] economia_db
    [+] dinero
        - usuarios.json
*/

Recuerda

Cada base de dates has un indentificador interno, esto hará que se puedan diferenciar en caso de que uses una db con el mismo nombre en diferentes carpetas (ya sean sub directorios o la carpeta principal donde se guardan tus bases de dates).

Ten en cuenta que si usas el Modo #2 y quieres usar los dates de esa db en otro archivo, debes de colocar los mismos dates especificando el nombre, carpeta, sub y guardar_tiempo (en caso de hayas usado estas propiedades)

Si tu base de dates se modifica muchas veces en pequeños lapsos de tiempo (supongamos cada 1 segundo) se recomienda usar la propiedad guardar_tiempo del Modo #2, esto hará que tu base de dates(archivo) no se llegue a reescribir/actualizar rapidamente, obtenemos una mejor fluidez al momento de guardar los dates.

set(clave, valor, clave_split)

Este metodo te permite crear propiedades mediante una clave, tambien te permite actualizar dates existentes por nuevos.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres crear, puedes usar el . seguido de otro nombre para crear o para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el valor que recibira la propiedad que especificaste en el argumento clave.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para crear o para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con los dates actualizados

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.set('BoomDev', {xp: 0, nivel: 10}) // retorna una promesa: {BoomDev: {xp: 0, nivel: 10}}
niveles.set('BoomDev.xp', 100) // retorna una promesa: {BoomDev: {xp: 100, nivel: 10}}
niveles.set('MoDeR', 100) // retorna una promesa: {BoomDev: {xp: 100, nivel: 10}, MoDeR: 100}
niveles.set('MoDeR-dates-monedas', 200, "-") // retorna una promesa: {BoomDev: {xp: 100, nivel: 10}, MoDeR: {dates: {monedas: 200}}}
niveles.set('MoDeR.dates.banco', 1000) // retorna una promesa:{BoomDev: {xp: 100, nivel: 10}, MoDeR: {dates: {monedas: 200, banco: 1000}}}
niveles.set('RatSageM', []) // retorna una promesa: {BoomDev: {xp: 100, nivel: 10}, MoDeR: {dates: {monedas: 200, banco: 1000}}, RatSageM: []}

//Estructura de la base de dates niveles.json:
{
  "BoomDev": {
    "xp": 100,
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200,
      "banco": 1000
    }
  },
  "RatSageM": []
}

size()

Este metodo te permite get el numero de valores(claves/keys) de una base de dates.

Argumentos

Ninguno

Retorna

Retorna el numero de valores de la base de dates(claves/keys).

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

let length = niveles.size()
console.log(length) //Esto retorna 3 ya que solo hemos agregado 3 valores(claves): BoomDev, MoDeR y RatSageM

get(clave, clave_split)

Este metodo te permite get los dates(valores) de una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres get, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

Promesa con los dates que se obtuvo, de lo contrario undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.get('BoomDev') // retorna promesa: {xp: 100, nivel: 10}
niveles.get('BoomDev.nivel') // retorna promesa: 10
niveles.get('MoDeR-dates-banco', "-") // retorna promesa: 1000
niveles.get('Star') //retorna promesa: undefined

has(clave, clave_split)

//[alias]
has(clave, clave_split)

Este metodo te permite verificar si existe una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres verificar, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

true si la propiedad existe.
false si la propiedad no existe.

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.has('BoomDev') // retorna true
niveles.has('Mario') // retorna false
niveles.has('BoomDev.monedas') // retorna false
niveles.has('MoDeR-dates-monedas', "-") // retorna true

delete(clave, clave_split)

//[alias]
delete(clave, clave_split)

Este metodo te permite delete una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres delete, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

true si la propiedad se elimino correctamente.
false si la propiedad no se elimino (no existe).

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.delete('BoomDev.xp') //retorna true
niveles.delete('MoDeR.dates.banco') //retorna true
niveles.delete('Mario') //retorna false


niveles.has('MoDeR.dates.banco') // retorna false porque lo eliminamos
niveles.has('BoomDev.xp') // retorna false porque lo eliminamos

niveles.get('BoomDev') // retorna promesa: {nivel: 10}
niveles.get('MoDeR-dates', "-") // retorna promesa: {monedas: 200}


//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": []
}

dates()

Este metodo regresa todas las propiedades de la base de dates, en otras palabras todos los dates.

Argumentos

Ninguno

Retorna

Promesa con todos los dates.

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.dates().then(n => {
  console.log(n)
})

//console.log(n)
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 100
    }
  },
  "RatSageM": []
}

push(clave, valor, clave_split)

Este metodo te permite agregar un elemento a un array.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres agregar el elemento, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el elemento que se agregara en el array que especificaste en el argumento clave.
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

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.push('RatSageM', 'manzana') // retorna promesa: ["manzana"]
niveles.set('BMdev', {items: ["platano"]})
//retorna promesa: {BoomDev: {nivel: 10}, MoDeR: {dates: {monedas: 100}}, RatSageM: ["manzana"], BMdev: {items: ["platano"]}}

niveles.push('BMdev', 'sandia') // retorna Error (.catch)
niveles.push('BMdev.items', 'sandia') // retorna promesa: ["platano", "sandia"]


//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": ["manzana"],
  "BMdev": {
    "items": ["platano", "sandia"]
  }
}

extract(clave, valor, clave_split)

Este metodo te permite remover un elemento especifico de un array.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres remover el elemento, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el elemento que se removera del array que especificaste en el argumento clave.
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

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.extract('BMdev', 'platano') // retorna Error (.catch)
niveles.extract('RatSageM', 'manzana') // retorna promesa: []
niveles.extract('BMdev.items', 'platano') // retorna promesa: ["sandia"]
niveles.extract('BMdev.items', 'durazno') // retorna Error (.catch)


//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "BMdev": {
    "items": ["sandia"]
  }
}

add(clave, valor, clave_split)

Este metodo te permite add una cantidad especifica a una propiedad, el valor propiedad debe ser un numero.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres addle una cantidad especifica, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner la cantidad que se le adda a la propiedad que especificaste en el argumento clave, esto debe ser un numero.
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

Promesa con el valor actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.set('Nelson', 20)
//retorna promesa: {BoomDev: {nivel: 10}, MoDeR: {dates: {monedas: 200}}, RatSageM: [], BMdev: {items: ["sandia"]}, Nelson: 20}

niveles.add('Nelson', 25) //retorna promesa: 45
niveles.set('Sun.dates.monedas', 10)
//retorna promesa: {BoomDev: {nivel: 10}, MoDeR: {dates: {monedas: 200}}, RatSageM: [], BMdev: {items: ["sandia"]}, Nelson: 20, Sun: {dates: {monedas: 10}}}

niveles.add('Sun.dates', 90) // retorna Error (.catch)
niveles.add('Sun-dates-monedas', 90, "-") // retorna promesa: 100

console.log(niveles.size()) //Esto imprime 6 ya que hemos agregado 6 valores(claves): BoomDev, MoDeR, RatSageM, BMdev, Nelson y Sun

//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "BMdev": {
    "items": ["sandia"]
  },
  "Nelson": 45,
  "Sun": {
    "dates": {
      "monedas": 100
    }
  }
}

rem(clave, valor, clave_split)

Este metodo te permite rem una cantidad especifica a una propiedad, el valor propiedad debe ser un numero.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres remle una cantidad especifica, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner la cantidad que se le rema a la propiedad que especificaste en el argumento clave, esto debe ser un numero.
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

Promesa con el valor actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.rem('Nelson', 40) //retorna promesa: 5
niveles.rem('Sun.dates', 100) // retorna Error (.catch)
niveles.rem('Sun-dates-monedas', 100, "-") // retorna promesa: 0


//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "BMdev": {
    "items": ["sandia"]
  },
  "Nelson": 5,
  "Sun": {
    "dates": {
      "monedas": 0
    }
  }
}

keys(clave, clave_split)

Este metodo retorna un array con todos los nombres(keys) de las propiedades del objeto que especificaste.

Argumentos

clave (opcional): La clave es opcional, en el caso de que quieras get los nombres(keys) de un objeto especifico, puedes colocar el nombre del objeto. Si quieres get los nombres(keys) de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) En el caso de que directamente quieras get los nombres(keys) de una base de dates, no pongas ningun valor.
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

Promesa con un array que conhas los nombres de las propiedades(keys).

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.keys() //retorna promesa: ["BoomDev", "MoDeR", "RatSageM", "BMdev", "Nelson", "Sun"]
niveles.keys('BoomDev.nivel') // retorna Error (.catch)
niveles.keys('Sun.dates') ///retorna promesa: ["monedas"]

values(clave, clave_split)

Este metodo retorna un array con todos los valores de las propiedades del objeto que especificaste.

Argumentos

clave (opcional): La clave es opcional, en el caso de que quieras get los valores de un objeto especifico, puedes colocar el nombre del objeto. Si quieres get los valores de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) En el caso de que directamente quieras get los valores de una base de dates, no pongas ningun valor.
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

Promesa con un array que conhas los valores de las propiedades.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

niveles.values() //retorna promesa: [{nivel: 10}, {dates: {monedas: 200}}, [], {items: ["sandia"]}, {dates: {monedas:0}}]

niveles.values('BoomDev.nivel') // retorna Error (.catch)
niveles.values('Sun.dates') ///retorna promesa: [{monedas: 0}]

purgeall()

Este metodo te permite delete todos los dates de una base de dates especifica.

Argumentos

Ninguno

Retorna

true si se elimino todo correctamente.
false si no se elimino correctamente.

Ejemplos

const db = require('shinkdb');
let niveles = new db.createDB('niveles');

//Estructura actual de la base de dates niveles.json:
{
  "BoomDev": {
    "nivel": 10
  },
  "MoDeR": {
    "dates": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "BMdev": {
    "items": ["sandia"]
  },
  "Nelson": 5,
  "Sun": {
    "dates": {
      "monedas": 0
    }
  }
}


let status = niveles.purgeall()
console.log(status) //Esto retorna true

//Estructura actual de la base de dates niveles.json:
{} //No conhas nada ya que se elimino todo

sort(clave, valor, clave_split)

Este metodo te permite sort las propiedad de un objeto de forma descendente, ten en cuenta que el valor de las propiedades que quieras sort debe ser un numero.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras sort las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres sort 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 sort las propiedades de una base de dates.
valor: El valor tambien puede recibir dos tipos de valores, en el caso de que las propiedades del objeto que quieres sort tambien sean objetos y mantengan propiedades, puedes colocar el nombre de la propiedad que se usara como referencia para sortlos de forma descendente, en el caso de que estas propiedades tambien sean objetos, puedes usar el . seguido del nombre del objeto y la propiedad que quieres sort (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que el valor de la propiedad con la cual lo vas a sort no sea un objeto.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave y el argumento valor (por default es el .)

Retorna

Promesa con un array, este array conhas las propiedades ordenadas de forma descendente.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1

const db = require('shinkdb');
let economia = new db.createDB('guild_1', 'economia_db');

economia.set('BoomDev', 100)
economia.set('MoDeR', 40)
economia.set('ratsagem', 320)

/*
Estructura actual de la base de dates guild_1.json:

{
  "BoomDev": 100,
  "MoDeR": 40,
  "ratsagem": 320
}

*/

economia.sort(false, false)
//retorna promesa: [{clave: 'ratsagem', valor: 320}, {clave: 'BoomDev', valor: 100}, {clave: 'MoDeR', valor: 40}]


/////////////////////////////////////////////////////


//ejemplo_2
const db = require('shinkdb');
let economia = new db.createDB('guild_1', 'economia_db');
economia.set('BoomDev', {monedas: 100})
economia.set('MoDeR', {monedas: 40})
economia.set('ratsagem', {monedas: 320})

/*
Estructura actual de la base de dates guild_1.json:

{
  "BoomDev": {
    "monedas": 100
  },
  "MoDeR": {
    "monedas": 40
  },
  "ratsagem": {
    "monedas": 320
  }
}

*/

economia.sort(false, "monedas")
//retorna promesa: [{clave: 'ratsagem', valor: {monedas: 320)}, {clave: 'BoomDev', valor: {monedas: 100}}, {clave: 'MoDeR', valor: {monedas: 40)}]


/////////////////////////////////////////////////////


//ejemplo_3
const db = require('shinkdb');
let economia = new db.createDB('guild_2', 'economia_db');
let usuarios_data = {
  'BoomDev': 100,
  'MoDeR': 40,
  'ratsagem': 320
}
economia.set('usuarios', usuarios_data)

/*
Estructura actual de la base de dates guild_2.json:

{
  "usuarios": {
    "BoomDev": 100
    "MoDeR": 40
    "ratsagem": 320
  }
}

*/

economia.sort("usuarios", false)
//retorna promesa: [{clave: 'ratsagem', valor: 320}, {clave: 'BoomDev', valor: 100}, {clave: 'MoDeR', valor: 40}]


/////////////////////////////////////////////////////


//ejemplo_4
const db = require('shinkdb');
let economia = new db.createDB('guild_3', 'economia_db');
let usuarios_data = {
  "BoomDev": {monedas: 50},
  "MoDeR": {monedas: 67},
  "ratsagem": {monedas: 4}
}
economia.set('usuarios', usuarios_data)


/*
Estructura actual de la base de dates guild_3.json:

{
  "usuarios": {
    "BoomDev": {
      "monedas": 50
    },
    "MoDeR": {
      "monedas": 67
    },
    "ratsagem": {
      "monedas": 4
    }
  }
}

*/

economia.sort("usuarios", "monedas")
//retorna promesa: [{clave: 'MoDeR', valor: {monedas: 67)}, {clave: 'BoomDev', valor: {monedas: 50}}, {clave: 'ratsagem', valor: {monedas: 4)}]


/////////////////////////////////////////////////////


//ejemplo_5
const db = require('shinkdb');
let economia = new db.createDB('guild_4', 'economia_db');

let usuarios = {
  "BoomDev": {monedas: 10, medallas: 15},
  "moder": {monedas: 50, medallas: 20},
  "ratsagem": {monedas: 25, medallas: 5}
}
economia.set('servidores.dates', usuarios)

/*
Estructura actual de la base de dates guild_4.json:

{
 'servidores': {
    'dates': {
      'BoomDev': {
        'monedas': 10,
        'medallas': 15
      },
      'moder': {
        'monedas': 50,
        'medallas': 20
      },
      'ratsagem': {
        'monedas': 25,
        'medallas': 5
      }
    }
  }
}

*/

economia.sort('servidores.dates', "medallas")

/*
retorna promesa:

[
  {clave: 'moder', valor: {monedas: 50, medallas: 20}},
  {clave: 'BoomDev', valor: {monedas: 10, medallas: 15}},
  {clave: 'ratsagem', valor: {monedas: 25, medallas: 5}}
]

*/



/////////////////////////////////////////////////////


//ejemplo_6
const db = require('shinkdb');
let economia = new db.createDB('guild_5', 'economia_db');

let usuarios = {
  "BoomDev": {stats: {monedas: 10}},
  "moder": {stats: {monedas: 50}},
  "ratsagem": {stats: {monedas: 25}}
}
economia.set('servidores.dates', usuarios)

/*
Estructura actual de la base de dates guild_5.json:

{
 'servidores': {
    'dates': {
      'BoomDev': {
        'stats': {
          'monedas': 10
        }
      },
      'moder': {
        'stats': {
          'monedas': 50
        }
      },
      'ratsagem': {
        'stats': {
          'monedas': 25
        }
      }
    }
  }
}

*/

economia.sort('servidores-dates', "stats-monedas", "-") //Estoy usando el - como separador en lugar del .

/*
retorna promesa:

[
  {clave: 'moder', valor: {stats: {monedas: 50}}},
  {clave: 'ratsagem', valor: {stats: {monedas: 25}}},
  {clave: 'BoomDev', valor: {stats: {monedas: 10}}}
]

*/

random(clave, cantidad, clave_split)

Este metodo te permite get una cantidad especifica de propiedades aleatoriamente (random), nunca se repetiran.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras get aleatoriamente una cantidad especifica de propiedades de un objeto, puedes colocar el nombre del objeto. Si quieres get aleatoriamente una cantidad especifica de 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 tengas propiedades que no sean objetos anidados.
cantidad: Aqui deberas de poner la cantidad(un numero) de propiedades random que se obtendra del objeto que especificaste en el argumento clave.
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

Promesa con un array, este array conhas las propiedades que fueron seleccionadas aleatoriamente.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require('shinkdb');
let giveaway = new db.createDB('giveaway');

giveaway.set('BoomDev', {ganadas: 0})
giveaway.set('MoDeR', {ganadas: 0})
giveaway.set('ratsagem', {ganadas: 0})
giveaway.set('Sun', {ganadas: 0})
giveaway.set('BMdev', {ganadas: 0})
giveaway.set('ruru', {ganadas: 0})

//Estructura actual de la base de dates giveaway.json:
{
  "BoomDev": {
    "ganadas": 0
  },
  "MoDeR": {
    "ganadas": 0
  },
  "ratsagem": {
    "ganadas": 0
  },
  "pedro": {
    "ganadas": 0
  },
  "BMdev": {
    "ganadas": 0
  },
  "ruru":  {
    "ganadas": 0
  }
}

giveaway.random(false, 4)
//retorna una promesa (las propiedades son aleatorias, esto es solo un ejemplo):
/*

[
  {clave: BoomDev, valor: {ganadas: 0}},
  {clave: ruru, valor: {ganadas: 0}},
  {clave: pedro, valor: {ganadas: 0}},
  {clave: MoDeR, valor: {ganadas: 0}}
]

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require('shinkdb');
let giveaway = new db.createDB('giveaway1');
let usuarios = {
  "12132131231242343": {ganadas: 0},
  "12132454545454543": {ganadas: 2},
  "13243242342342343": {ganadas: 1},
  "12138786867868683": {ganadas: 6},
  "18989896797978973": {ganadas: 0},
  "12121212135345346":  {ganadas: 5}
}
giveaway.set('users_ID', usuarios)


//Estructura actual de la base de dates giveaway1.json:
{
  "users_ID": {
    "12132131231242343": {
      "ganadas": 0
    },
    "12132454545454543": {
      "ganadas": 2
    },
    "13243242342342343": {
      "ganadas": 1
    },
    "12138786867868683": {
      "ganadas": 6
    },
    "18989896797978973": {
      "ganadas": 0
    },
    "12121212135345346":  {
      "ganadas": 5
    }
  }
}

giveaway.random("users_ID", 3)
//retorna una promesa (las propiedades son aleatorias, esto es solo un ejemplo):
/*

[
  {clave: 13243242342342343, valor: {ganadas: 1}},
  {clave: 12138786867868683, valor: {ganadas: 6}},
  {clave: 12121212135345346, valor: {ganadas: 5}}
]

*/

existDB(nombre_db)

Este metodo te permite verificar si existe una especifica base de dates en la carpeta databases o en sub directorio.

Argumentos

nombre_db: Aqui debe de ir el nombre de la base de dates que quires verificar si existe, si usaste la opcion del sub directorio en el constructor createDB, esto automaticamente buscara en el sub directorio, de lo contrario se buscara en la carpeta databases si no usaste esta opcion.

Retorna

true si la base de dates existe.
false si la base de dates no existe.

Ejemplos

/*
Nuestra estructura de dbs deberia ser esta:

[–] node_modules
[+] databases
    [+] economia_db
        - guild_1.json
        - guild_2.json
        - guild_3.json
        - guild_4.json
        - guild_5.json
    - niveles.json
    - giveaway.json
    - giveaway1.json
*/

//ejemplo_1 usare un sub directorio
const db = require("shinkdb");
let economia = new db.createDB("guild_1", "economia_db") //Estoy obteniendo el archivo guild_1.json que esta dentro del sub directorio "economia_db"
console.log(economia.existeDB("guild_2")) //retorna true
console.log(economia.existeDB("guild_5")) //retorna true
console.log(economia.existeDB("guild_8")) //retorna false
console.log(economia.existeDB("niveles")) //retorna false


//ejemplo_2 sin usar sub directorio
const db = require("shinkdb");
let niveles = new db.createDB("niveles") //Estoy obteniendo el archivo niveles.json que esta dentro de la carpeta databases
console.log(niveles.existeDB("giveaway")) //retorna true
console.log(niveles.existeDB("giveaway1")) //retorna true
console.log(niveles.existeDB("guild_8")) //retorna false
console.log(niveles.existeDB("mydb")) //retorna false

find(clave, callback(), clave_split)

Este metodo retorna el valor de la primera propiedad que cumpla la condicion del callback, si no encuentra nada regresara undefined. Es similar al Array.find

Argumentos

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 objeto. 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 dates.
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.

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 una promesa con el valor de la primera propiedad que cumpla la condicion del callback, de lo contrario retornara undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let escuela = new db.createDB("escuela")

escuela.set('Mario', {edad: 15, apellido: "garcia"})
escuela.set('Pedro', {edad: 12, apellido: "rojas"})
escuela.set('Juan', {edad: 10, apellido: "perez"})
escuela.set('Jair', {edad: 16, apellido: "gonzales"})

/* Estructura actual de la base de dates escuela.json:

{
  "Mario": {
    "edad: 15,
    "apellido: "garcia"
  },
  "Pedro": {
    "edad: 12,
    "apellido: "rojas"
  },
  "Juan": {
    "edad: 10,
    "apellido: "perez"
  },
  "Jair": {
    "edad: 16,
    "apellido: "gonzales"
  }
}

*/

escuela.find(false, (v) => v.edad == 16).then(nuevos => { //v es el elemento que se esta procesando en ese momento

  /* Ahora nuevos debera de contener esto:
    {
      "edad": "16",
      "apellido": "gonzales"
    }
  */

  if(nuevos == undefined) return console.log("Ningun alumno has 16 años")
  return console.log(`El alumno ${nuevos.apellido} has ${nuevos.edad} años!`)
}).catch(error => console.log(error))

//Esto da como resultado: "El alumno gonzales has 16 años!"


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let registros = new db.createDB("registros")

let registrados = {
  "ID_1": {
    "username": "BoomDev",
    "password": "xxxxxxxx",
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "age": 18
  }
}

registros.set('usuarios', registrados)

/* Estructura actual de la base de dates registros.json:

{
  "usuarios": {
    "ID_1": {
      "username": "BoomDev",
      "password": "xxxxxxxx",
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "edad": 18
    }
  }
}

*/

registros.find("usuarios", (v) => v.username == "BoomDev").then(usuario => { //v es el elemento del objeto "usuarios" que se esta procesando en ese momento

  /* Ahora usuario debera de contener esto:
    {
      "username": "BoomDev",
      "password": "xxxxxxxx",
      "edad": 20
    }
  */

  if(usuario == undefined) return console.log("No existe este usuario.")
  let nombre = usuario.username
  let contra = usuario.password
  let edad = usuario.edad
  return console.log(`dates, username: ${nombre}, contraseña: ${contra}, edad: ${edad}`)
}).catch(error => console.log(error))

//Esto da como resultado: "dates, username: BoomDev, contraseña: xxxxxxxx, edad: 20"

filter(clave, callback(), clave_split)

Este metodo retorna un objeto con todas las propiedades que cumplan la condicion del callback, si no encuentra nada regresara un objeto vacio {}. Es similar al Array.filter solo que en vez de regresar un nuevo array, regresa un nuevo objeto.

Argumentos

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 objeto. 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 dates.
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.

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 una promesa con un objeto que conhas todas las propiedades que cumplan la condicion del callback, de lo contrario retornara un objeto vacio {}.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let seleccion = new db.createDB("seleccion")

seleccion.set('Mario', 18)
seleccion.set('Pedro', 20)
seleccion.set('Juan', 12)
seleccion.set('Jair', 13)
seleccion.set('Steve', 16)
seleccion.set('Axel', 10)

/* Estructura actual de la base de dates seleccion.json:

{
  "Mario": 18,
  "Pedro": 20,
  "Juan": 12,
  "Jair": 13,
  "Steve": 16,
  "Axel": 10
}

*/

seleccion.filter(false, (v) => v > 15).then(nuevos => { //Estoy especificando que el valor del elemento que se esta procesando sea mayor a 15

  /* Ahora nuevos debera de contener este objeto:
    {
      "Mario": 18,
      "Pedro": 20,
      "Steve": 16
    }
  */

  if(Object.keys(nuevos).length <= 0) return console.log("Ningun jugador has mas de 15 años")
  let jugadores = []
  for(var key in nuevos) {
    jugadores.push(`Nombre: ${key}, edad: ${nuevos[key]}`)
  }
  return console.log(jugadores.join("\n"))
})

/*Esto da como resultado:

Nombre: Mario, edad: 18
Nombre: Pedro, edad: 20
Nombre: Steve, edad: 16

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let registros2 = new db.createDB("registros2")

let registrados = {
  "ID_1": {
    "username": "BoomDev",
    "password": "xxxxxxxx",
    "lenguaje": "javascript"    
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "lenguaje": "javascript"    
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "lenguaje": "c++"    
    "age": 18
  }
}

registros2.set('users', registrados)

/* Estructura actual de la base de dates registros2.json:

{
  "users": {
    "ID_1": {
      "username": "BoomDev",
      "password": "xxxxxxxx",
      "lenguaje": "javascript"       
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "lenguaje": "javascript"       
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "lenguaje": "c++"     
      "edad": 18
    }
  }
}

*/

registros2.filter("users", (v) => v.lenguaje == "javascript").then(usuarios => {

  /* Ahora usuarios debera de contener este objeto:
    {
      "ID_1": {
        "username": "BoomDev",
        "password": "xxxxxxxx",
        "lenguaje": "javascript"       
        "edad": 20
      },
      "ID_2": {
        "username": "MoDeR",
        "password": "aaaaaaaa",
        "lenguaje": "javascript"       
        "edad": 19
      }
    }
  */
  if(Object.keys(usuarios).length <= 0) return console.log("Ningun usuario sabe javascript.")
  let lista = []

  for(var key in usuarios) {
    let nombre = usuarios[key].username
    let edad = usuarios[key].edad
    let lenguaje = usuarios[key].lenguaje

    lista.push(`[${key}] username: ${nombre}, edad: ${edad}, lenguaje: ${lenguaje}`)
  }
  return console.log(lista.join("\n"))
})

/*Esto da como resultado:

[ID_1] username: BoomDev, edad: 20, lenguaje: javascript
[ID_2] username: MoDeR, edad: 18, lenguaje: javascript

*/

map(clave, callback(), clave_split)

Este metodo retorna un array con los resultados de la condicion que se especifico en el callback. Es similar al Array.map

Argumentos

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 objeto. 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 dates.
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.

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 una promesa con un array que conhas todos los resultados que se especificó en el callback.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let puntaje = new db.createDB("puntajes")

puntaje.set('Mario', 2)
puntaje.set('Pedro', 4)
puntaje.set('Juan', 5)
puntaje.set('Jair', 6)

/* Estructura actual de la base de dates puntajes.json:

{
  "Mario": 2,
  "Pedro": 4,
  "Juan": 5,
  "Jair": 6
}

*/

puntaje.map(false, (v, key) => `Usuario: ${key}, puntaje: ${v*2}`).then(dates => { //v toma el valor del elemento que se esta procesando en ese momento, y key toma la clave del elemento que se esta procesando en ese momento

  /* Ahora dates debera de contener este array:

    ["Usuario: Mario, puntaje: 4",
     "Usuario: Pedro, puntaje: 8",
     "Usuario: Juan, puntaje: 10",
     "Usuario: Jair, puntaje: 12"]
  */

  return console.log(dates.join("\n"))
})

/*Esto da como resultado:

Usuario: Mario, puntaje: 4
Usuario: Pedro, puntaje: 8
Usuario: Juan, puntaje: 10
Usuario: Jair, puntaje: 12

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let users_lb = new db.createDB("userslb")

let usuarios = {
  "servidor_1": {
    "BoomDev": 8,   
    "MoDeR": 6,
    "Mario": 1,
    "Pedro": 8
  },
  "servidor_2": {
    "Juan": 4,   
    "RatSageM": 5,
    "Steve": 7
  },
  "servidor:3": {
    "reDoM": 1,
    "Jack": 4
  }
}

users_lb.set('leaderboard', usuarios)

/* Estructura actual de la base de dates userslb.json:

{
  "leaderboard": {
    "servidor_1": {
      "BoomDev": 8,   
      "MoDeR": 6,
      "Mario": 1,
      "Pedro": 8
    },
    "servidor_2": {
      "Juan": 4,   
      "RatSageM": 5,
      "Steve": 7
    },
    "servidor_3": {
      "reDoM": 1,
      "Jack": 4
    }
  }
}

*/

users_lb.map("leaderboard.servidor_1", (v, key) => `Usuario: ${key} | puntos: ${v*3}`).then(usuarios => {

  /* Ahora usuarios debera de contener este array:

  ["Usuario: BoomDev | puntos: 24",
   "Usuario: MoDeR | puntos: 18",
   "Usuario: Mario | puntos: 3",
   "Usuario: Pedro | puntos: 24"]

  */

  return console.log(usuarios.join("\n"))
})

/*Esto da como resultado:

Usuario: BoomDev | puntos: 24
Usuario: MoDeR | puntos: 18
Usuario: Mario | puntos: 3
Usuario: Pedro | puntos: 24

*/

some(clave, callback(), clave_split)

Este metodo comprueba si al menos una propiedad del objeto(la base de dates) cumple con la condicion que se especificó en el callback. Es similar al Array.some

Argumentos

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 objeto. 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 dates.
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.

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 al menos una propiedad del objeto cumple con la condicion del callback se cumple, de lo contrario retornara false.

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let puntaje = new db.createDB("puntajes")

puntaje.set('Mario', 2)
puntaje.set('Pedro', 4)
puntaje.set('Juan', 5)
puntaje.set('Jair', 6)

/* Estructura actual de la base de dates puntajes.json:

{
  "Mario": 2,
  "Pedro": 4,
  "Juan": 5,
  "Jair": 6
}

*/

let verificar = puntaje.some(false, (v) => v == 6)
if(verificar) {
  console.log("Un usuario has 6 puntos.")
}
else{
  console.log("Ningun usuario has 6 puntos.")
}

/*Esto da como resultado:
"Un usuario has 6 puntos"

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let users_lb = new db.createDB("userspt")

let usuarios = {
  "user001": {
    "nombre": "BoomDev",   
    "puntos": 10
  },
  "user002": {  
    "nombre": "Juan",   
    "puntos": 4
  },
  "user003": {
    "nombre": "reDoM",   
    "puntos": 2
  }
}

users_lb.set('leaderboard', usuarios)

/* Estructura actual de la base de dates userspt.json:

{
  "leaderboard": {
    "user001": {
      "nombre": "BoomDev",   
      "puntos": 10
    },
    "user002": {  
      "nombre": "Juan",   
      "puntos": 4
    },
    "user003": {
      "nombre": "reDoM",   
      "puntos": 3
    }
  }
}

*/

console.log(users_lb.some("leaderboard", (v) => v.nombre == "BoomDev")) // 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

setIndex(clave, index, valor, clave_split)

Este metodo te permite remplazar un elemento especifico de un array a travez de su index (posicion).

Argumentos

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 objeto. 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 dates.
index: Aqui deberas de poner el indice(index) del elemento que quieres remplazar en el array, esto es un numero.
valor: Aqui deberas de colocar el nuevo valor que tomará el elemento del indice(index) que especificaste en el parametro index
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

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let mercado_db = new db.createDB("mercado")

mercado_db.set('frutas', [
  "platano",
  "durazno",
  "manzana",
  "zanahoria"
])

/* Estructura actual de la base de dates mercado.json:
{
  "frutas": [
    "platano",
    "durazno",
    "manzana",
    "zanahoria"
  ]
}

*/

mercado_db.setIndex("frutas", 3, "piña") // retorna promesa: ["platano", "durazno", "manzana", "piña"]

delIndex(clave, index, clave_split)

Este metodo te permite remover un elemento especifico de un array a travez de su index (posicion).

Argumentos

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 objeto. 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 dates.
index: Aqui deberas de poner el indice(index) del elemento que quieres remover del array, esto es un numero.
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

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let mercado_db = new db.createDB("mercado")

mercado_db.set('frutas', [
  "platano",
  "durazno",
  "manzana",
  "zanahoria"
])

/* Estructura actual de la base de dates mercado.json:
{
  "frutas": [
    "platano",
    "durazno",
    "manzana",
    "zanahoria"
  ]
}

*/

mercado_db.delIndex("frutas", 3) // retorna promesa: ["platano", "durazno", "manzana"]

/////////////////////////////////////////////////////


//ejemplo_2

const db = require("shinkdb");
let economy_db = new db.createDB("economydb")

economy_db.set("usuarios", [
  {nombre: "BoomDev"},
  {nombre: "moder"},
  {nombre: "pedro"}
])

/* Estructura actual de la base de dates economydb.json:

{
  "usuarios": [
    {"nombre": "BoomDev"},
    {"nombre": "moder"},
    {"nombre": "pedro"}
  ]
}

*/
economy_db.get("usuarios").then(usuarios => {
  let index = usuarios.findIndex(u => u.nombre == "pedro")
  if(index != -1) {
    economy_db.delIndex("usuarios", index).then(nuevo_array => {
      console.log(nuevo_array)
    }).catch(error => console.log(error))
  }
  else{
    console.log("No hay ningun usuario con el nombre pedro.")
  }
}).catch(error => console.log(error))

/*
Resultado:

[
  {"nombre": "BoomDev"},
  {"nombre": "moder"}
]

findKey(clave, callback(), clave_split)

Este metodo retorna la clave de la primera propiedad que cumpla la condicion del callback, si no encuentra nada regresara undefined. Es similar al Array.findIndex, solo que en vez de retornar el indice, regresa la clave.

Argumentos

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 objeto. 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 dates.
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.

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 una promesa con la clave de la primera propiedad que cumpla la condicion del callback, de lo contrario retornara undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let escuela = new db.createDB("escuela")

escuela.set('Mario', {edad: 15, apellido: "garcia"})
escuela.set('Pedro', {edad: 12, apellido: "rojas"})
escuela.set('Juan', {edad: 10, apellido: "perez"})
escuela.set('Jair', {edad: 16, apellido: "gonzales"})

/* Estructura actual de la base de dates escuela.json:

{
  "Mario": {
    "edad: 15,
    "apellido: "garcia"
  },
  "Pedro": {
    "edad: 12,
    "apellido: "rojas"
  },
  "Juan": {
    "edad: 10,
    "apellido: "perez"
  },
  "Jair": {
    "edad: 16,
    "apellido: "gonzales"
  }
}

*/

escuela.findKey(false, (v) => v.edad == 16).then(alumno => { //v es el elemento que se esta procesando en ese momento

  //Ahora alumno debera de contener 'Jair'
    
  if(alumno == undefined) return console.log("Ningun alumno has 16 años")
  return console.log(`El alumno ${alumno} has 16 años!`)
}).catch(error => console.log(error))

//Esto da como resultado: "El alumno Jair has 16 años!"


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let registros = new db.createDB("registros")

let registrados = {
  "ID_1": {
    "username": "BoomDev",
    "password": "xxxxxxxx",
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "age": 18
  }
}

registros.set('usuarios', registrados)

/* Estructura actual de la base de dates registros.json:

{
  "usuarios": {
    "ID_1": {
      "username": "BoomDev",
      "password": "xxxxxxxx",
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "edad": 18
    }
  }
}

*/

registros.findKey("usuarios", (v) => v.username == "BoomDev").then(id => { //v es el elemento del objeto "usuarios" que se esta procesando en ese momento

  // Ahora id debera de contener 'ID_1'
   

  if(id == undefined) return console.log("No existe este usuario.")
  return console.log(`El ID del usuario BoomDev es: ${id}`)
}).catch(error => console.log(error))

//Esto da como resultado: "El ID del usuario BoomDev es: ID_1"

partition(clave, callback(), clave_split)

Este metodo divide un objeto(base de dates) en dos objetos donde el primer objeto conhas las propiedades que cumplan con la condicion del callback y el segundo objeto con las propiedades que no la condicion.

Argumentos

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 objeto. 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 dates.
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.

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 un Array con dos elementos, el primer elemento seria un objeto con las propiedades que cumplieron con la condicion del callback y el segundo elemento un objeto con las que no lo cumplieron.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes getlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require("shinkdb");
let clases_rpg = new db.createDB("rpg")

clases_rpg.set('Mario', {hp: 200, clase: "enano"})
clases_rpg.set('MoDeR', {hp: 200, clase: "enano"})
clases_rpg.set('BoomDev', {hp: 100, clase: "elfo"})
clases_rpg.set('ratsagem', {hp: 100, clase: "elfo"})

/* Estructura actual de la base de dates rpg.json:

{
  "Mario": {
    "hp: 200,
    "clase: "enano"
  },
  "Pedro": {
    "hp: 200,
    "clase: "enano"
  },
  "BoomDev": {
    "hp: 100,
    "clase: "elfo"
  },
  "ratsagem": {
    "hp: 100,
    "clase: "elfo"
  }
}

*/

//Usando (async/await)
let [enanos, elfos] = await clases_rpg.partition(false, (v) => v.clase == 'enano')
console.log(`Usuarios de clase enano: ${Object.keys(enanos).join(", ")}\nUsuarios de clase elfo: ${Object.keys(elfos).join(", ")}`)

//usando then/catch
clases_rpg.partition(false, (v) => v.clase == 'enano').then(clases => { //v es el elemento que se esta procesando en ese momento
  let [enanos, elfos] = clases

  console.log(`Usuarios de clase enano: ${Object.keys(enanos).join(", ")}\nUsuarios de clase elfo: ${Object.keys(elfos).join(", ")}`)
}).catch(error => console.log(error))

/*Esto da como resultado:

Usuarios de clase enano: Mario, MoDeR
Usuarios de clase elfo: BoomDev, ratsagem

Si imprimimos:
- console.log(enanos)
{
  Mario: { hp: 200, clase: 'enano' },
  MoDeR: { hp: 200, clase: 'enano' }
}

- console.log(elfos)
{
  BoomDev: { hp: 100, clase: 'elfo' },
  ratsagem: { hp: 100, clase: 'elfo' }
}
*/

/////////////////////////////////////////////////////


//ejemplo_2
const db = require("shinkdb");
let clases_rpg = new db.createDB("rpg")

let jugadores = {
  "ID_1": {
    "username": "BoomDev",
    "hp": 100,
    "clase": "elfo"
  },
  "ID_2": {
    "username": "MoDeR",
    "hp": 200,
    "clase": "enano"
  },
  "ID_3": {
    "username": "ratsagem",
    "hp": 100,
    "clase": "elfo"
  }
}

clases_rpg.set('servidor1', jugadores)

/* Estructura actual de la base de dates rpg.json:
{
  "servidor1": {
    "ID_1": {
      "username": "BoomDev",
      "hp": 100,
      "clase": "elfo"
    },
    "ID_2": {
      "username": "MoDeR",
      "hp": 200,
      "clase": "enano"
    },
    "ID_3": {
      "username": "ratsagem",
      "hp": 100,
      "clase": "elfo"
    }
  }
}
*/


//Usando (async/await)
let [enanos, elfos] = await clases_rpg.partition("servidor1", (v) => v.clase == 'enano')
console.log(`Usuarios de clase enano: ${enanos.map(e => e.username).join(", ")}\nUsuarios de clase elfo: ${elfos.map(e => e.username).join(", ")}`)
//usando then/catch
clases_rpg.partition("servidor1", (v) => v.clase == 'enano').then(clases => { //v es el elemento que se esta procesando en ese momento
  let [enanos, elfos] = clases

  console.log(`Usuarios de clase enano: ${enanos.map(e => e.username).join(", ")}\nUsuarios de clase elfo: ${elfos.map(e => e.username).join(", ")}`)
}).catch(error => console.log(error))

/*Esto da como resultado:

Usuarios de clase enano: MoDeR
Usuarios de clase elfo: BoomDev, ratsagem

Si imprimimos:
- console.log(enanos)
{
   ID_2: { username: 'MoDeR', hp: 200, clase: 'enano' }
}

- console.log(elfos)
{
  ID_1: { username: 'BoomDev', hp: 100, clase: 'elfo' },
  ID_3: { username: 'ratsagem', hp: 100, clase: 'elfo' }
}
*/

convert_megadtbs()

Este metodo es especial, usalo solo cuando quieras adaptar tu base de dates del npm mega-dtbs al shinkdb. Para adaptar tu base de dates del mega-dtbs a shinkdb, debes de poner el nombre "mega_db" en el constructor createDB. Asegurate de que el archivo mega_db.json se encuentre dentro de la carpeta databases.

Argumentos

Ninguno.

Retorna

Nada.

Demostracion

https://youtu.be/rouyoy0SJN0

Ejemplos

const db = require("shinkdb");
let shinkdb = new db.createDB("mega_db")
shinkdb.convert_megadtbs()

Estructura del error:

name: shinkdb ERROR.
message: El mensaje descriptivo del error.
type: El tipo de error que se produjo.
method: El metodo en el que se produjo el error.
param1: El valor ingresado en el primer argumento del metodo usado.
param2: El val

database JSON db base de dates

graceful-fs mkdirp path

@everything-registry/sub-chunk-2751

0.0.2

3 years ago

0.0.1

3 years ago