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

Complementos de Select (Funciones agregadas SQL)

Este módulo proporciona funciones auxiliares para facilitar el uso de funciones agregadas SQL dentro de tu sistema de consultas usando DB.Select().

Actualmente incluye soporte para:

• AVG
• COUNT
• MIN
• MAX

Estas funciones permiten generar expresiones SQL limpias, reutilizables y tipadas desde TypeScript.

Uso general

Todas las funciones reciben:

(nombreColumna, aliasOpcional)

Donde:

| Parámetro | Tipo | Descripción | | --------- | ----------------- | ---------------------------------- | | columna | string | Nombre de la columna de la tabla | | alias | string (opcional) | Nombre personalizado del resultado |

Retornan:

string

Lista para ser usada dentro de DB.Select().

Funciones disponibles

AVG()

Calcula el promedio de una columna.

const [resultado] = await DB.Select([
  AVG(usuarios.iduser, "promedio")
])
.from(usuarios())
.execute();

Resultado:

{ promedio: '4.0000000000000000' }

COUNT()

Cuenta la cantidad de registros.

const datos = await DB.Select([
  COUNT(usuarios.iduser, "cantidad")
])
.from(usuarios())
.execute();

Resultado:

[ { cantidad: 9 } ]

MIN()

Obtiene el valor mínimo de una columna.

const datos = await DB.Select([
  MIN(usuarios.iduser, "minimo")
])
.from(usuarios())
.execute();

Resultado:

[ { minimo: 1 } ]

MAX()

Obtiene el valor máximo de una columna.

const [datos] = await DB.Select([
  MAX(usuarios.iduser, "maximo")
])
.from(usuarios())
.execute();

Resultado:

{ maximo: 7 }

Alias (pseudoNombre)

El segundo parámetro permite definir el nombre del campo retornado:

AVG("usuarios.edad", "edad_promedio")

Genera internamente:

AVG(usuarios.edad) AS edad_promedio

Si no se especifica alias:

AVG("usuarios.edad")

Genera:

AVG(usuarios.edad)

Ejemplo completo

const resultado = await DB.Select([
  COUNT(usuarios.iduser, "total"),
  MAX(usuarios.iduser, "mayor"),
  MIN(usuarios.iduser, "menor"),
  AVG(usuarios.iduser, "promedio")
])
.from(usuarios())
.execute();

Resultado:

[
  {
    total: 9,
    mayor: 7,
    menor: 1,
    promedio: "4.0000000000000000"
  }
]

Objetivo del módulo

Este módulo existe para:

• Evitar escribir SQL manual repetitivo
• Mejorar legibilidad del código
• Mantener consistencia en alias
• Facilitar composición de consultas dinámicas
• Integrarse naturalmente con DB.Select()

Próximas mejoras sugeridas

Puedes ampliar fácilmente el módulo agregando:

• SUM()
• ROUND()

Siguiendo exactamente el mismo patrón usado aquí.

Ejemplo de Uso ZORMZ

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.5.0 son mas estables , las anteriores estaban en desarrollo y presentan multiples errores
• version estable 1.5.0

Licencia

ISC © Yukio-kayaba