dbtabla es un modulo de Node.js valido registrado en npm registry.
Para instalar use npm install command:
$ npm install dbtabla
dbtabla es una interface de alto nivel abstracta para generar consultas sql compatible con mysql, sqlite3 y postgesql. Escrito en JavaScript
Para usar este modulo es nesesario extender la clase Connect para crear la clase de conexion para el motor de base de datos elegido ejemplo:
// file mysqlTable.js
const {MYSQL_DB,connect}=require("dbtabla")
const mysql=require("mysql")
class mysqlTable extends connect
{
constructor(params)
{
super(params,MYSQL_DB)
// aqui su codigo de inicializacion y conexion
}
query(sql)
{
// aqui su codigo para ejecutar consultas
}
__escapeString(str)
{
// aqui su codigo para filtrar sqli
}
__keysInTable(table)
{
// aqui su codigo para obtener los metadatos de la tabla
}
}
Deben ser redefinidos los metodos constructor, query, __escapeString, __keysInTable
En el constructor se establecera la conexion
query: debe ejecutar el sql recibido en su parametro y retornar una promesa
__escapeString: escapara el texto que reciba para evitar inyecciones sqli
__keysInTable: obtendra los metadatos de la tabla del primer parametro y retornara una promesa con los metadatos
Ejempo:
__keysInTable(table)
{
return new Promise((res,rej)=>
{
res({
tabla:table,
colums:[
{
name:string,
type:string,
defaultNull:boolean,
primary:boolean,
unique:boolean,
defaul:string,
autoincrement:boolean
},
.
.
.]
})
})
}
y su uso seria de la siguiente manera
const mysql=require("./mysqlTable.js")
let connect= new mysql({/* params mysql */})
let test1=connect.tabla("test1")
test1.insert(/* datos a insertar */).then(ok=>
{
console.log(ok)
}).catch(e=>
{
console.log(e)
})
El metodo tabla() de mysqlTable retorna un objeto dbTabla que representa la tabla en la base de datos con el mismo nombre del parametro
Clase abstracta para administrar la conexion con la base de datos
Factoriza y retorna un objeto dbTabla que representara a la tabla con el nombre del primer parametro
tabla {string}: Nombre de la tabla en la base de datoscallback {function} (opcional): Funcion que sera ejecutada cuando se verifique la existencia de la tabla, esta funcion recibira un parametro que sera el objeto dbTabla creado y si la tabla no es encontrada el parametro sera nullverify {boolean} (opcional): indica si la verificacion se realizara al instante o se esperara a la primera consultaVerifica si un modelo existe y lo retorna si no existe retorna false
tabla {string}: Nombre del modeloAgrega un modelo
model {sqlModel|object|string}: Si es un objeto instanceado de tabla-model se agregara a la lista de modelos, si es un objeto pero no de tabla-model se tomara como los datos para factorizar un modelo deberia tener el formato {tabla:String, campos:Array, foreingKey:Array} y si es un string deberia ser una clausula sql CREATE TABLE de la cual se factorizara el modelo
Mas documentacion sobre tabla-model..//ejemplo 1
const model=require("tabla-model")
let connect= new Connect(/*parametros de conexion */)
const test2=new model("test2",{
campos:[
{
name:"id",
type:"int",
primary:true,
},
{
name:"row1",
type:"text"
},
{
name:"row2",
type:"int",
},
{
name:"row3",
type:"date",
}
]
})
connect.addModel(test2)
//ejemplo 2
let connect= new Connect(/*parametros de conexion */)
connect.addModel({
tabla:"test2",
campos:[
{
name:"id",
type:"int",
primary:true,
},
{
name:"row1",
type:"text"
},
{
name:"row2",
type:"int",
},
{
name:"row3",
type:"date",
}
]
})
//ejemplo 3
let connect= new Connect(/*parametros de conexion */)
connect.addModel(`CREATE TABLE test2 (
id int,
row1 text,
row2 int,
row3 date,
primary key (id)
)`)
Cargar todos los modelos existentes en el directorio path
path {string}: directorio de modelosVerifica si la tabla esta representada en un modelo si el parametro create es true se intentara crear la tabla e inicializarla retorna una promesa si no existe el modelo lanzara un catch
tabla {string}: nombre de la tablacreate {boolean}: indica si se creara e inicializara la tabla en la base de datosMetodo abstracto que verificara la existencia de la tabla en la base de datos y retornar una promesa el valor de la promesa debe ser en el siguiente formato
{
tabla:{String}, // nombre de la tabla
colums:{Array} // columnas de la tabla
}
tabla {string}: Nombre de la tablaMetodo abstracto debe ejecutar una consulta sql en la base de datos y retornar una promesa
sql {string}: consulta sqlMetodo abstracto debe terminar la conexion
dbTabla es una representacion de una tabla en una base de datos para realizar operaciones comunes como insertar, editar, eliminar y consultar con una interface sencilla de usar, dbtabla cuenta con los siguientes metodos
Con este metodo se pueden insertar datos en la tabla de forma sencilla pasando los datos como parametros individuales, en un array o object, retornara una promesa
// tu codigo...
let mitabla=connect.tabla("mitabla")
// insert into mitabla (id,row1,row2) values(1,"un texto","otro texto")
mitabla.insert(1,"un texto","otro texto")
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// insert into mitabla (id,row1,row2) values(1,"un texto","otro texto")
mitabla.insert([1,"un texto","otro texto"])
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// insert into mitabla (id,row1,row2) values(1,"un texto","otro texto")
mitabla.insert({id:1,row1:"un texto",row2:"otro texto"})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Las tres llamadas daran el mismo resultado, si se tiene un campo que esta marcado como AUTO_INCREMENT en mysql o un campo de serial en postgresql se puede dar el valor de null o obviarse cuando se pasan los datos en un objeto
En el siguien ejemplo en campo id es el valor auto_increment
// tu codigo...
let mitabla=connect.tabla("mitabla")
// insert into mitabla (row1,row2) values("un texto","otro texto")
mitabla.insert(null,"un texto","otro texto")
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// insert into mitabla (row1,row2) values("un texto","otro texto")
mitabla.insert([null,"un texto","otro texto"])
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// insert into mitabla (row1,row2) values("un texto","otro texto")
mitabla.insert({row1:"un texto",row2:"otro texto"})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Realiza cambios a los elementos de una tabla y devuelve una promesa
sets {object}: Campos de la tabla a editar
where {string|object}: exprecion booleana sql para where, si es de tipo object los atributos seran el campo y su valor con lo que se comparara por defecto se utilizara el operador and para separar las comparaciones pero si se antepone el operador || al nombre del atributo se usara el operador or y el operrador = para realizar las comparaciones para cambiarlo solo se tiene que colocar el operador de comparacion al final del nombre del atributo los operadores aceptados son <,<=,>,>=,=,!= y para like %, si el valor del atributo es un array todos sus elemenos seran comparados con el nombre del atributo unado el operador OR.
Ejemplo de uso
// tu codigo...
let mitabla=connect.tabla("mitabla")
// update mitabla set row1='mas texto' row2='mas texto 2' where id=1
mitabla.update({row1:"mas texto",row2:"mas texto 2"},{id:1})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// update mitabla set row1='mas texto' row2='mas texto 2' where id=1 and row='un texto'
mitabla.update({row1:"mas texto",row2:"mas texto 2"},"id=1 and rpw='un texto'")
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// update mitabla set row1='mas texto' row2='mas texto 2' where id=1 and row='un texto'
mitabla.update({row1:"mas texto",row2:"mas texto 2"},{id:1,row:'un texto'})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// update mitabla set row1='mas texto' row2='mas texto 2' where id=1 or row='un texto'
mitabla.update({row1:"mas texto",row2:"mas texto 2"},{"||id":1,row:'un texto'})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Edita el elemento en el que el parametro id sea igual a valor de la clave primaria y devuelve una promesa
sets {object}: Campos de la tabla a editar
id {numeric|string}: valor de la clave primaria .
Ejemplo de uso
// tu codigo...
let mitabla=connect.tabla("mitabla")
// update mitabla set row1='mas texto' row2='mas texto 2' where id=1
mitabla.updateById({row1:"mas texto",row2:"mas texto 2"},1)
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Elimina uno o mas elementos de la tabla y devuelve una promesa
where {string|object}: exprecion booleana sql para where, si es de tipo object los atributos seran el campo y su valor con lo que se comparara por defecto se utilizara el operador and para separar las comparaciones pero si se antepone el operador || al nombre del atributo se usara el operador or y el operrador = para realizar las comparaciones para cambiarlo solo se tiene que colocar el operador de comparacion al final del nombre del atributo los operadores aceptados son <,<=,>,>=,=,!= y para like %, si el valor del atributo es un array todos sus elemenos seran comparados con el nombre del atributo unado el operador OR.Ejemplo de uso
// tu codigo...
let mitabla=connect.tabla("mitabla")
// delete from mitabla where id=1
mitabla.delete("id=1")
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// delete from mitabla where id=1
mitabla.delete({id:1})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// delete from mitabla where id=1 and row="un texto"
mitabla.delete({id:1,row:"un texto"})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
// delete from mitabla where id=1 or row="un texto"
mitabla.delete({"||id":1,row:"un texto"})
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Elimina el elemento de la tabla en el que el parametro id sea igual a valor de la clave primaria y devuelve una promesa
id {numeric|string}: valor de la clave primaria.Ejemplo de uso
// tu codigo...
let mitabla=connect.tabla("mitabla")
// delete from mitabla where id=1
mitabla.deleteById(1)
.then(ok=>console.log(ok))
.catch(err=>console.log(err))
Este metodo realiza una consulta a la base de datos y retorna una promesa el valor de la promesa sera un array y cada elemeto del array sera un objeto dbRow con los datos del fila, todos los parametros son opcionales e intercambiables si no se pasa ningun parametro solo realizara una consulta sencilla obteniendo todos los campos de la tabla, retorna una promesa.
campos {array|string|object}: Este parametro si es un array sera la lista de campos
a obtener de la consulta en caso de ser un de tipo object sera join y todos los demas se correna hasta join, si es un string sera where y todos los demas parametros se correran.
join {object|string} en caso de ser un string sera tomado como el parametro where, si join es de tipo object cada atributo de este objeto sera el nombre de la tabla a la que hace referencia la clave foranea y el valor puede ser
el nombre del campo que comparten las dos tabla o una exprecion booleana sql ejemplo {"unatabla":"id"} o {"unatabla":"unatabla.id=mitabla.row1"}, para indicar si el join es left, ringt o innert solo hay que anteponer al nombre de la tabla los operadores > < = respectivamente ejemplo para left join {">unatabla":"id"}
por defecto es natural join.
where {string|object}: exprecion booleana sql para where, si es de tipo object los atributos seran el campo y su valor con lo que se comparara por defecto se utilizara el operador and para separar las comparaciones pero si se antepone el operador || al nombre del atributo se usara el operador or y el operrador = para realizar las comparaciones para cambiarlo solo se tiene que colocar el operador de comparacion al final del nombre del atributo los operadores aceptados son <,<=,>,>=,=,!= y para like %, si el valor del atributo es un array todos sus elemenos seran comparados con el nombre del atributo unado el operador OR.
group {string|object}: es parametro sera la clausula group by de la consulta si es de tipo object sera tomado como el parametro having
having {string}: sera la exprecion booleana sql para having funciona igual que el parametro where
order {string}: si esta presente sera el valor de order by
limit {numeric|string}: el limite de resultados a obtener
Si cualquiera de los parametros es de tipo Number sera tomado como el parametro limit y los parametros siguientes seran ignorados o si es de tipo String y coincide con la exprecion
/^[\s]*(group[\s]+by|having|order[\s]+by|limit)/i sera tomado como el parametro que conicida y los siguientes se correran
Ejemplo de uso:
// tu codigo...
let mitabla=connect.tabla("mitabla")
// select mitabla.* from mitabla;
mitabla.select()
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
// select id,row1 from mitabla;
mitabla.select(["id","row1"])
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
// select mitabla.* from mitabla where id=1 or id=2;
mitabla.select("id=1 or id=2")
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
/*
select mitabla.* from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
*/
mitabla.select({">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"})
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
/*
select mitabla.* from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
where id=1 or id=2;
*/
mitabla.select({">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"},"id=1 or id=2")
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
/*
select mitabla.* from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
oder by id
*/
mitabla.select({">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"},"oder by id")
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
/*
select mitabla.* from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
oder by id
*/
mitabla.select({">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"},"oder by id")
.then(data=>{
console.log(data)
}).catch(e=>console.log(e))
Igual que select pero solo se obtendra de la promesa un objeto dbRow con con la fila obtenida si no se obtiene nada sea null.
Igual que el metodo anterior pero en este caso seleccionara por el valor de la clave primaria
campos {array|string|object}: Este parametro si es un array sera la lista de campos
a obtener de la consulta, si es de tipo object sera join y todos los demas se correna hasta join.
join {object|string}: En caso de no ser un object sera tomado como el parametro id, si join es de tipo object cada atributo de este objeto sera el nombre de la tabla a la que hace referencia la clave foranea y el valor puede ser
el nombre del campo que comparten las dos tabla o una exprecion booleana sql ejemplo {"unatabla":"id"} o {"unatabla":"unatabla.id=mitabla.row1"}, para indicar si el join es left, ringt o innert solo hay que anteponer al nombre de la tabla los operadores > < = respectivamente ejemplo para left join {">unatabla":"id"}
por defecto es natural join.
id {numeric|string}: valor de la clave primaria.
Ejemplo de uso:
// tu codigo...
let mitabla=connect.tabla("mitabla")
// select mitabla.* from mitabla where id=1;
mitabla.selectById(1)
.then(row=>{
console.log(row)
}).catch(e=>console.log(e))
// select id,row1 from mitabla where id=1;
mitabla.selectById(["id","row1"],1)
.then(row=>{
console.log(row)
}).catch(e=>console.log(e))
/*
select mitabla.* from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
where id=1;
*/
mitabla.selectById({">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"},1)
.then(row=>{
console.log(row)
}).catch(e=>console.log(e))
/*
select id,row1 from mitabla
left join tabla1 using(row1)
ringt join tabla2 on(tabla2.id=mitabla.row2)
where id=1;
*/
mitabla.selectById(["id","row1"],{">tabla1":"row1","<tabla2":"tabla2.id=mitabla.row2"},1)
.then(row=>{
console.log(row)
}).catch(e=>console.log(e))
Este metodo realiza una busqueda en la tabla con un algoritmo interno sql y devuelve una promesa.
texto {string}: texto a buscar
campos_bus {array}: lista de campos en los que se buscara el texto
campos {array|string|object}: Este parametro si es un array sera la lista de campos
a obtener de la consulta en caso de ser un de tipo object sera join y todos los demas se correna hasta join, si es un string sera where y todos los demas parametros se correran.
join {object|string} en caso de ser un string sera tomado como el parametro where, si join es de tipo object cada atributo de este objeto sera el nombre de la tabla a la que hace referencia la clave foranea y el valor puede ser
el nombre del campo que comparten las dos tabla o una exprecion booleana sql ejemplo {"unatabla":"id"} o {"unatabla":"unatabla.id=mitabla.row1"}, para indicar si el join es left, ringt o innert solo hay que anteponer al nombre de la tabla los operadores > < = respectivamente ejemplo para left join {">unatabla":"id"}
por defecto es natural join.
where {string|object}: exprecion booleana sql para where, si es de tipo object los atributos seran el campo y su valor con lo que se comparara por defecto se utilizara el operador and para separar las comparaciones pero si se antepone el operador || al nombre del atributo se usara el operador or y el operrador = para realizar las comparaciones para cambiarlo solo se tiene que colocar el operador de comparacion al final del nombre del atributo los operadores aceptados son <,<=,>,>=,=,!= y para like %, si el valor del atributo es un array todos sus elemenos seran comparados con el nombre del atributo unado el operador OR.
group {string}: es parametro sera la clausula group by de la consulta
having {string}: sera la exprecion booleana sql para having
order {string}: si esta presente sera el valor de order by
limit {numeric|string}: el limite de resultados a obtener
Esta clase representa una fila obtenida en dbTabla#select(), dbTabla#selectOne() o dbTabla#selectById()
Guarda los cambios de la fila en la tabla donde fue factorizado el objeto y retorna una promesa
// tu codigo...
let mitabla=connect.tabla("mitabla")
// select mitabla.* from mitabla where id=1;
mitabla.selectById(1)
.then(row=>{
row.row1="cambio de texto"
// update mitabla set row1="cambio de texto" where id=1
row.update().then(ok=>
{
console.log(ok)
}).catch(e=>console.log(e))
}).catch(e=>console.log(e))
Elimina la fila de la base de datos y retorna una promesa
// tu codigo...
let mitabla=connect.tabla("mitabla")
// select mitabla.* from mitabla where id=1;
mitabla.selectById(1)
.then(row=>{
// delete from mitabla where id=1
row.delete().then(ok=>
{
console.log(ok)
}).catch(e=>console.log(e))
}).catch(e=>console.log(e))
FAQs
interface de alto nivel para sql
We found that dbtabla demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Multiple high-impact npm maintainers confirm they have been targeted in the same social engineering campaign that compromised Axios.
Security News
Axios compromise traced to social engineering, showing how attacks on maintainers can bypass controls and expose the broader software supply chain.
Security News
Node.js has paused its bug bounty program after funding ended, removing payouts for vulnerability reports but keeping its security process unchanged.