ZORMZ

Un ORM ligero escrito en TypeScript para MySQL y PostgreSQL, diseñado para ser simple, rápido y extensible.
Permite conectarse a una base de datos, definir tablas desde TypeScript con autocompletado y tipado, y generar tablas automáticamente.

Características

• Compatible con ESM y CommonJS
• Tipado completo en TypeScript
• Builder con sintaxis encadenada: select().from().where().execute()
• Insert múltiple con arrays
• Update y Delete con condiciones
• Definición de columnas con encadenamiento:
  • int().Pk().$()
  • varchar(200).Default("hola").$()
• Generación automática de tablas en MySQL y PostgreSQL
• Sin dependencias pesadas
• Fácil de extender

Instalación

npm install zormz

Uso basico

importacion ESM

import {
  connecionLocal,
  getConexion,
  defineTable,
  generateTable,
  int,
  varchar,
  DB,
  eq,
  ORQ,
} from "zormz";

importacion COMMONJS

const {
  connecionLocal,
  getConexion,
  defineTable,
  generateTable,
  int,
  varchar,
  DB,
  eq,
  ORQ,
} = require("zormz");

Conexion a la base de datos

MYSQL

const conexionMysql: connecionLocal = {
  database: "pruebas",
  host: "localhost",
  password: "",
  port: 3306,
  user: "root",
};

getConexion("mysql", conexionMysql);

PG

//Conexion por red , aqui solo se pone la ruta que por defecto te arroja la base de datos de la nube
const conexion2: connecionRed = {
  connectionString: "direccion",
};

const conexion: connecionLocal = {
  database: "pruebamaster",
  host: "localhost",
  password: "zainmaster123",
  port: 5432,
  user: "postgres",
};

getConexion("pg", conexion);

Definicion de Tablas

export const prueba1 = defineTable("prueba1", {
  id: int().Pk().$(),
  valor: varchar(200).Default("hola").$(),
  resultado: int().Default(0).$(),
  fechaRegistro: timestamp().required().now().$(),
  fechaUpdate: timestamp().required().now().onUpdate().$(),
});

o

export function generateTables() {
  return {
    colaborador: defineTable("colaborador", {
      idcolaborador: int().Pk().$(),
      idusuario: int().Required().$(),
      nombrecompleto: varchar(150).$(),
      dni: varchar(9).$(),
      rol: varchar(50).$(),
      diastrabajo: varchar(200).Default("sabado - domingo").$(),
      estado: varchar().Check(["pendiente", "completado", "rechazado"]).$(),
    }),
    permisos: defineTable("permisos", {
      idpermiso: int().Pk().$(),
      nombre: varchar(100).$(),
      descripcion: varchar(250).$(),
      estado: bool().default(true).$(),
    }),
    detallespermisos: defineTable("detallespermisos", {
      iddetallepermiso: int().Pk().$(),
      idcolaborador: int().$(),
      idppermiso: int().Default(0).$(),
    }),
  };
}

Notas importantes

• .pk() define la columna como clave primaria
• .Default() entrega un valor por defecto
• .$() finaliza la definicion y entrega un valor compatible con $columns
• .required() Indica que los valores de la fila no podran ser null, si o si un valor obligatorio
• .now() Solo esta disponible para timestamp , indica fecha automatica de registra
• .onUpdate() Tomara la fecha actual cada ves que se haga un update
• .Check() Solo para varchar , puedes decirle que valores esta obligado a recibir y no otros

Generacion de tablas

generateTable(prueba1(), prueba1.$columns,true);//true para ver la definicion

Esto crea la tabla en la base de datos respetando tipos, claves primarias y valores por defecto.

Eliminar tablas

await dropTable(prueba4());

Insertar Datos

await DB.Insert(prueba1(), [prueba1.valor, prueba1.resultado])
  .Values([
    ["hola mundo", 1],
    ["prueba", 0],
  ])
  .Returning(prueba1.id)
  .execute();

Select de Datos

const datos = await DB.select()
  .from(prueba1())
  .where(eq(prueba1.id, 1))
  .execute(true);

Update de Datos

.set() Recibe un objeto con clave valor de las tablas o un array con UP

await DB.Update(prueba1())
  .set({ valor: "nuevo valor", resultado: 2 })
  .where(eq(prueba1.id, 1))
  .execute();

o

//Usar la funcion UP
const response = await DB.Update(producto())
  .set([UP(producto.stockactual, `${producto.stockactual} -  4`, true)])
  .where(eq(producto.idproducto, 4))
  .execute();

Delete de Datos

await DB.Delete(prueba1())
  .where(ORQ(prueba1.id, 2, 3))
  .execute();

JOINS

const { detallespermisos, colaborador, permisos } = generateTables();

const response = await DB.Select([
  detallespermisos.iddetallepermiso,
  colaborador.nombrecompleto,
  colaborador.dni,
  permisos.nombre,
  permisos.estado,
])
  .from(detallespermisos())
  .innerJOIN(
    colaborador(),
    eq(colaborador.idcolaborador, detallespermisos.idcolaborador, false),
  )
  .innerJOIN(
    permisos(),
    eq(permisos.idpermiso, detallespermisos.idppermiso, false),
  )
  .execute();

Operadores y Helpers SQL

eq(valor1,valor2,literal = true)

comparacion de igualdad

  eq("dni", dni);//2do valor como variable 
  eq("id","idLaptops",true)//2do valor como campo de tabla 

neq(valor1,valor2,literal = true)

comparacion de negacion

  neq("dni", dni);//2do valor como variable 
  neq("id","idLaptops",true)//2do valor como campo de tabla 

AND(...condiciones)

Agrupa múltiples condiciones con AND.

AND(eq(), eq(), neq())

ANDD(...condiciones)

Agrupa múltiples condiciones con AND.

ANDD([eq(), eq(), neq()])

OR(...condiciones)

Agrupa múltiples condiciones con OR.

OR(neq(), eq(), eq())

ORD([])

Agrupa múltiples condiciones con OR.

ORD([neq(), eq(), eq()])

ORQ(campo,...valores)

Genera multiples comparaciones OR para un mismo campo.

ORQ("id",1,2,3);
// => id = 1 or id = 2 or id = 3

ORQD(campo,valores[])

Genera multiples comparaciones OR para un mismo campo.

ORQD("id",[1,2,3]);
// => id = 1 or id = 2 or id = 3

ILIKE(campo,valor)

Comparacion insensible a mayusculas/minusculas

ILIKE('nombre','%juan%');
// => nombre ILIKE '%juan%'

NOW(campo,dias,minor = true)

Compara una fecha con la fecha actual menos X días.

NOW('fecha_creacion', 7)
// => ( fecha_creacion < NOW() - INTERVAL '7 days')

NOW('fecha_creacion', 7, false)
// => ( fecha_creacion > NOW() - INTERVAL '7 days')

NULL(campo)

valida si un campo es NULL

NULL('delete_at');
//=> delete_at IS NULL

NOTNULL(campo)

valida si un campo no es NULL

NOTNULL('deleted_at')
// => deleted_at IS NOT NULL

MAYOR(campo,valor)

Comparacion mayor que (>)

MAYOR('edad',18);
// => edad > 18

MENOR(campo,valor)

Comparacion menor que (<)

MENOR('edad', 18)
// => edad < 18

Ejemplo de Uso

import {
  connecionLocal,
  getConexion,
  defineTable,
  generateTable,
  int,
  varchar,
  DB,
  eq,
  ORQ,
} from "zormz";

const conexion: connecionLocal = {
  database: "pruebamaster",
  host: "localhost",
  password: "pgZORMZ",
  port: 5432,
  user: "postgres",
};

getConexion("pg", conexion);
//MYSQL
//getConexion("mysql", conexion);

const prueba1 = defineTable("prueba1", {
  id: int().Pk().$(),
  valor: varchar(200).Default("hola").$(),
  resultado: int().Default(0).$(),
});

generateTable(prueba1(), prueba1.$columns);

async function pruebaData() {
  await DB.Insert(prueba1(), [prueba1.valor, prueba1.resultado])
    .Values([
      ["hola mundo", 1],
      ["prueba", 0],
    ])
    .execute();

  const datos = await DB.select().from(prueba1()).execute();
  console.log(datos);

  await DB.Update(prueba1())
    .set({ valor: "actualizado", resultado: 2 })
    .where(eq(prueba1.id, 1))
    .execute();

  await DB.Delete(prueba1())
    .where(ORQ(prueba1.id, 2, 3))
    .execute();
}

pruebaData().catch(console.error);

Notas

• ORM en version inicial con enfoque de tipado y autompletado
• Compatible con MYSQL y PG
• Preparado para extenderse
• Las versiones +1.3.0 son mas estables , las anteriores estaban en desarrollo y presentan multiples errores
• version estable 1.4.6
• Se corrigio la compatiblidad de PG al momento de realizar Insert :c losiento

Licencia

ISC © Yukio-kayaba