zormz 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# ZORM
+Un ORM simple pero poderoso para el uso de cualquier usuario , no te enredes con cosas como definir las tablas 

package/dist/index.cjs

@@ -0,0 +1,591 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  AND: () => AND,
+  BDconnection: () => BDconnection,
+  DB: () => DB,
+  DeleteR: () => DeleteR,
+  ILIKE: () => ILIKE,
+  NOTNULL: () => NOTNULL,
+  NULL: () => NULL,
+  OR: () => OR,
+  ORQ: () => ORQ,
+  QueryBuilder: () => QueryBuilder,
+  Select: () => Select,
+  Update: () => Update,
+  eq: () => eq,
+  getConexion: () => getConexion,
+  getRed: () => getRed,
+  mayor: () => mayor,
+  menor: () => menor,
+  now: () => now
+});
+module.exports = __toCommonJS(index_exports);
+
+// conection/db.ts
+var conexion1;
+var BDconnection = class {
+  constructor(bd, datos) {
+    this.tipo = "pg";
+    this.tipo = bd;
+    this.connection = datos;
+  }
+  async connecionMyql() {
+    try {
+      const mysql = await import("mysql2/promise");
+      if ("connectionString" in this.connection)
+        throw new Error("La conexion mysql no tiene una conexion de red");
+      const pool = mysql.createPool({
+        host: this.connection.host,
+        port: this.connection.port,
+        database: this.connection.database,
+        user: this.connection.user,
+        password: this.connection.password
+      });
+      return pool;
+    } catch (error) {
+      throw new Error("Mysql no esta instalado . para instalarlo corre : npm install mysql2 ");
+    }
+  }
+  async connectionPG() {
+    try {
+      const { Pool } = await import("pg");
+      if ("connectionString" in this.connection) {
+        console.log("conexion en linea");
+        return new Pool({
+          connectionString: this.connection.connectionString,
+          ssl: {
+            rejectUnauthorized: false
+          }
+        });
+      }
+      return new Pool({
+        host: this.connection.host,
+        port: this.connection.port,
+        database: this.connection.database,
+        user: this.connection.user,
+        password: this.connection.password
+      });
+    } catch (error) {
+      console.error(
+        "PostgreSQL no esta instalado. para instalarlo corre : npm install pg"
+      );
+    }
+  }
+  async executeConsulta({
+    query,
+    valores = void 0,
+    mensaje
+  }) {
+    try {
+      if (this.tipo === "mysql") {
+        const pool = await this.connecionMyql();
+        const [rows] = await pool.query(query, [valores]);
+        return rows;
+      } else if (this.tipo === "pg") {
+        let query2 = query;
+        if (valores) {
+          let iterador = 1;
+          query2 = "";
+          for (let i = 0; i < query.length; i++) {
+            if (query[i] == "?") {
+              query2 += `$${iterador}`;
+              iterador++;
+            } else {
+              query2 += query[i];
+            }
+          }
+        }
+        const pool2 = await this.connectionPG();
+        const respuesta = await pool2.query(query2, valores);
+        if (!respuesta) {
+          throw new Error(` Este usuario no esta registrado `);
+        }
+        if ("rows" in respuesta) {
+          if (respuesta.rows[0].id) {
+            return { insertId: respuesta.rows[0].id };
+          }
+          return respuesta.rows;
+        }
+      }
+    } catch (error) {
+      console.log(error);
+      if (typeof error === "object" && error !== null && "code" in error) {
+        if (error.code === "ETIMEDOUT") {
+          throw new Error(`Su red esta limitando el acceso`);
+        }
+        throw new Error(`${mensaje} : ${error} query ${query}`);
+      }
+    }
+  }
+};
+function getConexion(bd, datos) {
+  conexion1 = new BDconnection(bd, datos);
+}
+function getRed() {
+  return conexion1;
+}
+
+// conection/middleware/delete.ts
+var _condicion, _tabla;
+var DeleteR = class {
+  /**
+   *
+   * @param {string} tabla -- tabla a eliminar
+   * @example
+   * delete from tabla
+   */
+  constructor(conexion, tabla) {
+    __privateAdd(this, _condicion);
+    __privateAdd(this, _tabla);
+    __privateSet(this, _tabla, tabla);
+    __privateSet(this, _condicion, "");
+    this.conexion = conexion;
+  }
+  /**
+   *
+   * @param {string} condicion -- condicional de tabla
+   * @example
+   * DB.Delete(tabla).WHERE(eq(valor,valor))
+   * DB.Delete(tabla).WHERE(AND(eq(valor,valor), eq(valor2,valor2)))
+   */
+  where(condicion) {
+    if (!condicion || typeof condicion !== "string") {
+      throw new Error("La tabla es un campo obligatorio");
+    }
+    __privateSet(this, _condicion, ` where ${condicion}`);
+    return this;
+  }
+  async execute() {
+    const query = `DELETE FROM ${__privateGet(this, _tabla)} ${__privateGet(this, _condicion)}`;
+    const respuesta = await this.conexion.executeConsulta({
+      query,
+      mensaje: "Ocurrio un error al momento de eliminar un dato"
+    });
+    return respuesta.affectedRows;
+  }
+};
+_condicion = new WeakMap();
+_tabla = new WeakMap();
+
+// conection/middleware/insertar.ts
+var QueryBuilder = class {
+  /**
+   * @throws {Error} Si la consulta es vacía.
+   */
+  /**
+   * @param {string[]} parametros - campo obligatorio
+   * @param {string} tabla - nombre de la ta tabla - campo obligatorio
+   * @param {string[]} values - campo obligatorio
+   */
+  constructor(conexion, tabla, parametros) {
+    if (!parametros || !Array.isArray(parametros)) {
+      throw new Error(`campos obligatorios`);
+    }
+    if (!tabla || typeof tabla !== "string") {
+      throw new Error("Nombre tabla obligatorio");
+    }
+    this.tabla = tabla;
+    this.parametros = parametros;
+    this.valores = [];
+    this.valorRetorno = null;
+    this.conexion = conexion;
+  }
+  /**
+   *
+   * @param {arrayData | arrayDatas} values
+   * @example
+   * //para un salo dato
+   * ['dato1','dato2']
+   * //para varios datos
+   * [['dato1','dato1/2'],['dato2','dato2/2']]
+   *
+   * @returns
+   */
+  Values(values) {
+    if (!values || !Array.isArray(values)) {
+      throw new Error("los valores tienen que ser tipo array");
+    }
+    this.valores = values;
+    return this;
+  }
+  async execute() {
+    this.valorRetorno = 1;
+    let query1 = `INSERT INTO ${this.tabla} `;
+    let param = "";
+    let arrayArrays = false;
+    let paramespaces = "";
+    if (typeof this.parametros !== "string") {
+      if (Array.isArray(this.valores)) arrayArrays = true;
+      this.parametros.forEach((valor, index) => {
+        param += valor;
+        paramespaces += ` ? `;
+        if (index < this.parametros.length - 1) {
+          param += ", ";
+          paramespaces += ", ";
+        }
+      });
+    }
+    let query = `${query1} (${param}) VALUES `;
+    if (arrayArrays) {
+      query += ` ? `;
+    } else {
+      query += `(${paramespaces})`;
+    }
+    const respuesta = await this.conexion.executeConsulta({
+      query,
+      valores: this.valores,
+      mensaje: `Ocurrio un error al ingresar datos a ${this.tabla} `
+    });
+    return respuesta.insertId;
+  }
+};
+
+// conection/middleware/select.ts
+var Select = class {
+  /**
+   * @param {string[]} parametros - campo obligatorio
+   * @param {string} tabla - nombre de la ta tabla - campo obligatorio
+   * @param {string[]} values - campo obligatorio
+   * @param {string} condition - tabla1.id = tabla2.idtabla1 - id='2' - id='2' AND id='3'
+   */
+  constructor(conexion, parametros = "*") {
+    this.conexion = conexion;
+    this.valores = !Array.isArray(parametros) ? false : true;
+    this.parametros = parametros;
+    this.tabla = void 0;
+    this.innerJoin = "";
+    this.leftjoins = "";
+    this.rigthjoins = "";
+    this.limit = "";
+    this.condicion = "";
+    this.orderBy = "";
+  }
+  /**
+   * @param {string} tabla - nombre de la ta tabla - campo obligatorio
+   */
+  from(tabla) {
+    if (!tabla || typeof tabla !== "string") {
+      throw new Error("La tabla es un campo obligatorio");
+    }
+    this.tabla = tabla;
+    return this;
+  }
+  innerJOIN(tabla, condition) {
+    if (!tabla || typeof tabla !== "string") {
+      throw new Error("La tabla es un campo obligatorio");
+    }
+    this.innerJoin += ` INNER JOIN ${tabla} ON ${condition}`;
+    return this;
+  }
+  leftJoin(tabla, condition) {
+    if (!tabla || typeof tabla !== "string") {
+      throw new Error("La tabla es un campo obligatorio");
+    }
+    this.leftjoins += ` LEFT JOIN ${tabla} ON ${condition}`;
+    return this;
+  }
+  rigthJoin(tabla, condition) {
+    if (!tabla || typeof tabla !== "string") {
+      throw new Error("La tabla es un campo obligatorio");
+    }
+    this.rigthjoins += ` RIGHT JOIN ${tabla} ON ${condition}`;
+    return this;
+  }
+  /**
+   * @param {string} condition - tabla1.id = tabla2.idtabla1 - id='2' - id='2' AND id='3'
+   */
+  where(condition = void 0) {
+    if (condition === void 0 || !condition) {
+      this.condicion = "";
+    } else {
+      if (this.condicion.length < 2) {
+        this.condicion += `WHERE `;
+      }
+      this.condicion += ` ${condition}`;
+    }
+    return this;
+  }
+  /**
+   * @typedef { "ASC" | "DESC" } tipos
+   */
+  /**
+   *
+   * @param {{
+   *  [clave:string]:tipos
+   * }} objeto --Filtrado
+   * @example
+   * select().orderBy({nombre:'DESC',id:'ASC'});
+   */
+  OrderBy(objeto) {
+    if (typeof objeto !== "object")
+      throw new Error("Solo se permite objetos , error de OrderBy");
+    if (Object.keys(objeto).length === 0)
+      throw new Error("No se permite los campos vacios");
+    this.orderBy = " ORDER BY ";
+    for (const [clave, valor] of Object.entries(objeto)) {
+      if (valor !== "ASC" && valor !== "DESC")
+        throw new Error("ASC o DESC requerido para la consulta");
+      this.orderBy += ` ${clave} ${valor},`;
+    }
+    this.orderBy = this.orderBy.slice(0, -1);
+    return this;
+  }
+  /**
+   *
+   * @param {Number} cantidad
+   */
+  LIMIT(cantidad = 1) {
+    if (typeof cantidad != "number") {
+      throw new Error("Cantidad tiene que ser un numero");
+    }
+    this.limit = `LIMIT ${cantidad}`;
+    return this;
+  }
+  /**
+   *
+   * @param {String} texto
+   */
+  /**
+   * @returns {Promise<Array<Object>>}
+   */
+  async execute() {
+    let selectFields = "*";
+    if (this.valores) {
+      if (typeof this.parametros !== "undefined" && typeof this.parametros !== "string") {
+        selectFields = this.parametros.join(",");
+      }
+    }
+    const query = `SELECT ${selectFields} from ${this.tabla} ${this.innerJoin} ${this.leftjoins} ${this.rigthjoins} ${this.condicion} ${this.orderBy}  ${this.limit};`;
+    const respuesta = await this.conexion.executeConsulta({
+      query,
+      mensaje: "Ocurrio un error realizar un select"
+    });
+    return respuesta;
+  }
+};
+
+// conection/middleware/condicionals.ts
+var AND = (...valor1) => {
+  const separacion = valor1.join(" and ");
+  return `(${separacion})`;
+};
+var OR = (...valor1) => {
+  const separadosComas = valor1.join(" or ");
+  return `(${separadosComas})`;
+};
+var ORQ = (condicion1, ...condicionals) => {
+  const data2 = condicionals.map((dato) => {
+    if (typeof dato == "number" || typeof dato == "boolean") return ` '${condicion1}' = ${dato}`;
+    return ` '${condicion1}' = '${dato}' `;
+  });
+  const separador = data2.join(" or ");
+  return separador;
+};
+var ILIKE = (valor1, valor2) => {
+  return `${valor1} ILIKE '%${valor2}%'`;
+};
+var now = (variable, diasTrancurridos, minor = true) => {
+  if (typeof variable !== "string") {
+    throw new Error("Variable no valida");
+  }
+  if (typeof diasTrancurridos !== "number") {
+    throw new Error("dias Transcurridos no valido");
+  }
+  if (minor) {
+    return `( ${variable} < NOW() - INTERVAL '${diasTrancurridos} days')`;
+  }
+  return `( ${variable} > NOW() - INTERVAL '${diasTrancurridos} days')`;
+};
+var NULL = (variable) => {
+  return `${variable} IS NULL`;
+};
+var NOTNULL = (variable) => {
+  return `${variable} IS NOT NULL`;
+};
+var eq = (valor1, valor2, literal = true) => {
+  if (typeof valor1 === "string") valor1 = valor1.trim();
+  if (typeof valor2 === "string") valor2 = valor2.trim();
+  if (!literal) {
+    return `${valor1} = ${valor2}`;
+  }
+  return `${valor1} = '${valor2}'`;
+};
+var mayor = (valor, valor2) => {
+  return ` ${valor} > ${valor2} `;
+};
+var menor = (valor, valor2) => {
+  return ` ${valor} < ${valor2} `;
+};
+
+// conection/middleware/update.ts
+var Update = class {
+  /**
+   * @param {string} nombreTabla - nombre de la tabla a actualizar
+   */
+  constructor(conexion, nombreTabla) {
+    this.nombreTabla = "";
+    this.valores = "";
+    this.condicion = "";
+    if (typeof nombreTabla !== "string") {
+      throw new Error("el valor ingresado requiere un string");
+    }
+    if (nombreTabla === void 0 || !nombreTabla) {
+      throw new Error("El nombre de la tabla es requerido");
+    }
+    this.nombreTabla = nombreTabla;
+    this.conexion = conexion;
+  }
+  /**
+   * @param {Valores} valores - valores a actualizar
+   * @example
+   * .set({'campo1':'valor1', 'campo2':'valor2'})
+   */
+  set(valores) {
+    if (typeof valores !== "object") {
+      throw new Error("es requerido un objeto");
+    }
+    let valor = "";
+    for (const key in valores) {
+      if (valores.hasOwnProperty(key)) {
+        const value = valores[key];
+        if (value === void 0) continue;
+        valor += eq(key, value);
+        valor += ",";
+      }
+    }
+    valor = valor.slice(0, -1);
+    this.valores = valor;
+    return this;
+  }
+  /**
+   * @param {string} condicion - valor condicional
+   * @example
+   * //para completar una condicional puedes usar
+   * where(eq())
+   * where(AND())
+   * where(OR())
+   * where(ORQ())
+   */
+  where(condicion) {
+    if (condicion === void 0 || !condicion) {
+      this.condicion = "";
+    } else {
+      if (this.condicion.length < 2) {
+        this.condicion += `WHERE `;
+      }
+      this.condicion += `${condicion}`;
+    }
+    return this;
+  }
+  async execute() {
+    const query = `UPDATE ${this.nombreTabla} SET ${this.valores} ${this.condicion};`;
+    const respuesta = await this.conexion.executeConsulta({
+      query,
+      mensaje: "Error Update"
+    });
+    if (this.conexion.tipo === "mysql") {
+      return respuesta;
+    } else {
+      return {
+        resultado: respuesta.rows.info,
+        filasAfectadas: respuesta.rows.affectedRows
+      };
+    }
+  }
+};
+
+// conection/conexion.ts
+var DB = class {
+  /**
+   * @param {string} tabla - campo obligatorio
+   * @param {string[]} parametros - campo obligatorio
+   * @example
+   * DB.Insert('tabla',['campo1','campo2'])
+   */
+  static Insert(tabla, parametros) {
+    const conex = getRed();
+    return new QueryBuilder(conex, tabla, parametros);
+  }
+  /**
+   * @param {string[]} parametros - campo opcional
+   */
+  static select(parametros) {
+    const conex = getRed();
+    return new Select(conex, parametros);
+  }
+  /**
+   * @param {string} nombreTabla - nombre de la tabla a actualizar
+   */
+  static update(nombreTabla) {
+    const conex = getRed();
+    return new Update(conex, nombreTabla);
+  }
+  /**
+   *
+   * @param {string} nombreTabla -- tabla a eliminar
+   * @example
+   * delete from tabla
+   */
+  static Delete(nombreTabla) {
+    const conex = getRed();
+    return new DeleteR(conex, nombreTabla);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AND,
+  BDconnection,
+  DB,
+  DeleteR,
+  ILIKE,
+  NOTNULL,
+  NULL,
+  OR,
+  ORQ,
+  QueryBuilder,
+  Select,
+  Update,
+  eq,
+  getConexion,
+  getRed,
+  mayor,
+  menor,
+  now
+});