dbtabla 2.2.1 → 2.2.2

package/index.mjs

@@ -0,0 +1,4 @@
+import dbTabla from './index.js';
+
+export default dbTabla;
+export const { Connect, dbResult, dbRow, dbTablaError, procesingSql } = dbTabla;

package/lib/Connect.js

@@ -1,12 +1,12 @@
-const fs=require("fs")
-const path=require("path")
-const dbTablaModel=require("tabla-model")
-const dbTabla=require(__dirname+"/dbTabla.js")
-const procesingSql = require('./procesingSql')
-/**
-* Connect
-* clase abstracta para crear la clase de conexion a la base de datos
-*/
+const fs = require("fs")
+const path = require("path")
+const dbTablaModel = require("tabla-model")
+const dbTabla = require(__dirname + "/dbTabla.js")
+const procesingSql = require('./procesingSql')
+/**
+* Connect
+* clase abstracta para crear la clase de conexion a la base de datos
+*/
 class Connect {
     _escapeChar;
     _reserveIdentifiers;
@@ -17,248 +17,248 @@ class Connect {
     _models;
     _caheTablas;
     _createdTables;
-    _escapeString;
-    /**
-    * constructor de la clase
-    * @param {object} params - parametros de conexion
-    */
-    constructor(params,typeDB="")
-    {
-        this.config=params
-        this._escapeChar=""
-        this._reserveIdentifiers=["*"]
-        this._ar_aliased_tables=[]
-        this._dbprefix=""
-        this._swap_pre=""
-        this._information_schema = " "
-        this._models={}
-        this.typeDB=typeDB
-        this._caheTablas={}
-    }
-    /**
-    * retorna la configuracion para los helpers
-    * @return {object}
-    */
-    helpersConf()
-    {
-        return {
-            escapeChar:this._escapeChar,
-            reserveIdentifiers:this._reserveIdentifiers,
-            ar_aliased_tables:this._ar_aliased_tables,
-            dbprefix:this._dbprefix,
-            swap_pre:this._swap_pre,
-            typeDB:this.typeDB,
-            escapeString:typeof this._escapeString==="function"?e=>this._escapeString(e):null
-        }
-    }
-    /**
-    * retorna el modelo asociado a la tabla
-    * @param {string} tabla - nombre de la tabla
-    * @return {dbTablaModel|boolean} - si el modelo  no existe retorna false
-    */
-    model(tabla)
-    {
-
-        return this._models[tabla] instanceof dbTablaModel?this._models[tabla]:false
-    }
-    /**
-    * agrega un modelo a la lista de modelos interna
-    * @param {sqlModel|object|string} model - objeto modelo
-    */
-    addModel(model)
-    {
-        if(model instanceof dbTablaModel)
-        {
-            this._models[model.tabla]=model
-        }else if(typeof model==="object" && model!==null){
-            this._models[model.tabla]= new dbTablaModel(model.tabla,model)
-        }else {
-            this._models[model.tabla]= new dbTablaModel(model,this.helpersConf().escapeChar)
-        }
-
-    }
-    /**
-    * agrega todos los modelos existentes en un directorio a la lista interna
-    * @param {string} pathModel - directorio de modelos
-    */
-    pathModels(pathModel)
-    {
-        let files=fs.readdirSync(pathModel)
-        for(let i in files)
-        {
-
-            if(/(\.js)$/i.test(files[i]))
-            {
-                let model=require(path.join(pathModel,files[i]))
-                if(model instanceof dbTablaModel)
-                {
-                    this.addModel(model)
-                }
-
-            }
-
-        }
-
-    }
-    /**
-    * metodo abstracto en su redefinicion debere generar una
-    * consulta a la base de datos y debe retornar una promesa
-    * @param {string} query - consulta sql
-    * @return {Promise}
-    */
-    query(query)
-    {
-        return new Promise((res)=>
-        {
-            res(query)
-        })
-    }
-    /**
-    * construlle un objeto dbtabla asociado a el nombre
-    * de la tabla del primer parametro
-    * @param {string} tabla - nombre de la tabla en la base de datos
-    * @param {function} callback - funcion anomina que se ejecutara cuando se verifique la existencia de la tabla
-    * @param {boolean} verify - indicara si se verificara la existencia de la tabla o se esperara a la primera consulta
-    * @return {dbTabla}
-    */
-    tabla(tabla,callback,verify=false)
-    {
-        if(typeof this._caheTablas[tabla]!=="undefined")
-        {
-            typeof callback==="function"?callback(this._caheTablas[tabla]):null
-            return this._caheTablas[tabla]
-        }
-        return this._caheTablas[tabla] = new dbTabla({
-            tabla:tabla,
-            connection:this,
-            callback:callback,
-            config:this.helpersConf()
-        },verify)
-        //console.log(config)
-
-    }
-    /**
-    * metodo abstracto que escapara el texto sql
-    * @param {string} str - texto
-    * @return {string}
-    */
-    /*__escapeString(str)
-    {
-        return str
-    }*/
-
-
-    /**
-    * metodo 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
-    * }
-    * @param {string} table - nombre de la tabla
-    * @return {Promise}
-    */
-    _keysInTable(table)
-    {
-        return new Promise((res)=>
-        {
-            res({
-                tabla:table,
-                colums:[]
-            })
-        })
-    }
-    /**
-    * Verifica 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
-    *
-    * @param {string} tabla - nombre de la tabla
-    * @param {boolean} create - existencia en la base de datos
-    * @return {Promise}
-    */
-    inModel(tabla,create)
-    {
-        return new Promise((res,rej)=>{
-            if(!this.model(tabla))
-            {
-                rej()
-            }else
-            {
-                
-                if(create)
-                {
-                
-                    this._createTable(this.model(tabla))
-                        .then(res).catch(rej)
-                }else
-                {
-                    res(this.model(tabla).getData())
-                }
-            }
-        })
-    }
-    /**
-    * crea una tabla en la base de datos apartir de un modelo
-    * si la tabla tiene claves foraneas intentara crear primero
-    * las tablas a las que apuntan
-    * @param {dbTablaModel} model - objeto del modelo
-    * @return {Promise}
-    */
-    _createTable(model)
-    {
-       
-        return new Promise((res,rej)=>
-        {
-            this._createdTables={}
-            let rescursive=(foreingKey,i)=>
-            {
-                
-                if(foreingKey[i]!==undefined)
-                {
-                    try
-                    {
-                        this.tabla(foreingKey[i].reference,(t)=>
-                        {
-                            rescursive(foreingKey,++i) 
-                        },true)
-                    }catch(e){rej(e)}
-                }else {
-                    
-                    this.query(model.sql(this)).then(()=>{
-                        this._createdTables[model.tabla]=true
-                        this._initializeTable(model.tabla).then(()=>
-                            {
-                               
-                                res(model.getData())
-                            }).catch(rej)
-                    }).catch(rej)
-                }
-            }
-            rescursive(model.foreingKey(),0)
-        })
-    }
-    _initializeTable(tab)
-    {
-        return new Promise(async(res)=>
-        {
-            
-            let sql=new procesingSql(this.model(tab).getData(),this.helpersConf())
-            let init=this.model(tab).getData().init
-            
-            if(init.length<1)
-            {
-                return res()
-            }
-            for(let item of init)
-            {
-                await this.query(sql.insert(item))
-            }
-            res()
-
-        })
-
-    }
-}
-module.exports=Connect
+    _escapeString;
+    /**
+    * constructor de la clase
+    * @param {object} params - parametros de conexion
+    */
+    constructor(params, typeDB = "") {
+        this.config = params
+        this._escapeChar = ""
+        this._reserveIdentifiers = ["*"]
+        this._ar_aliased_tables = []
+        this._dbprefix = ""
+        this._swap_pre = ""
+        this._information_schema = " "
+        this._models = {}
+        this.typeDB = typeDB
+        this._caheTablas = {}
+    }
+    /**
+    * retorna la configuracion para los helpers
+    * @return {object}
+    */
+    helpersConf() {
+        return {
+            escapeChar: this._escapeChar,
+            reserveIdentifiers: this._reserveIdentifiers,
+            ar_aliased_tables: this._ar_aliased_tables,
+            dbprefix: this._dbprefix,
+            swap_pre: this._swap_pre,
+            typeDB: this.typeDB,
+            escapeString: typeof this._escapeString === "function" ? e => this._escapeString(e) : null
+        }
+    }
+    /**
+    * retorna el modelo asociado a la tabla
+    * @param {string} tabla - nombre de la tabla
+    * @return {dbTablaModel|boolean} - si el modelo  no existe retorna false
+    */
+    model(tabla) {
+
+        return this._models[tabla] instanceof dbTablaModel ? this._models[tabla] : false
+    }
+    /**
+    * agrega un modelo a la lista de modelos interna
+    * @param {sqlModel|object|string} model - objeto modelo
+    */
+    addModel(model) {
+        if (model instanceof dbTablaModel) {
+            this._models[model.tabla] = model
+        } else if (typeof model === "object" && model !== null) {
+            this._models[model.tabla] = new dbTablaModel(model.tabla, model)
+        } else {
+            this._models[model.tabla] = new dbTablaModel(model, this.helpersConf().escapeChar)
+        }
+
+    }
+    /**
+    * agrega todos los modelos existentes en un directorio a la lista interna
+    * @param {string} pathModel - directorio de modelos
+    */
+    pathModels(pathModel) {
+        const { pathToFileURL } = require('url')
+        let files = fs.readdirSync(pathModel)
+
+        let isEsmProject = false
+        try {
+            const pkgPath = path.join(process.cwd(), 'package.json')
+            if (fs.existsSync(pkgPath)) {
+                isEsmProject = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).type === 'module'
+            }
+        } catch (e) { }
+
+        for (let i in files) {
+
+            if (/(\.js|\.mjs|\.cjs)$/i.test(files[i])) {
+                let filePath = path.join(pathModel, files[i])
+
+                if (isEsmProject || /\.mjs$/i.test(files[i])) {
+                    import(pathToFileURL(filePath).href).then(module => {
+                        let model = module.default || module
+                        if (model instanceof dbTablaModel) {
+                            this.addModel(model)
+                        }
+                    }).catch(e => console.error(`Error loading ESM model ${files[i]}:`, e))
+                } else {
+                    try {
+                        let model = require(filePath)
+                        if (model && model.default) model = model.default
+                        if (model instanceof dbTablaModel) {
+                            this.addModel(model)
+                        }
+                    } catch (e) {
+                        import(pathToFileURL(filePath).href).then(module => {
+                            let model = module.default || module
+                            if (model instanceof dbTablaModel) {
+                                this.addModel(model)
+                            }
+                        }).catch(err => console.error(`Error loading model ${files[i]}:`, err))
+                    }
+                }
+
+            }
+
+        }
+
+    }
+    /**
+    * metodo abstracto en su redefinicion debere generar una
+    * consulta a la base de datos y debe retornar una promesa
+    * @param {string} query - consulta sql
+    * @return {Promise}
+    */
+    query(query) {
+        return new Promise((res) => {
+            res(query)
+        })
+    }
+    /**
+    * construlle un objeto dbtabla asociado a el nombre
+    * de la tabla del primer parametro
+    * @param {string} tabla - nombre de la tabla en la base de datos
+    * @param {function} callback - funcion anomina que se ejecutara cuando se verifique la existencia de la tabla
+    * @param {boolean} verify - indicara si se verificara la existencia de la tabla o se esperara a la primera consulta
+    * @return {dbTabla}
+    */
+    tabla(tabla, callback, verify = false) {
+        if (typeof this._caheTablas[tabla] !== "undefined") {
+            typeof callback === "function" ? callback(this._caheTablas[tabla]) : null
+            return this._caheTablas[tabla]
+        }
+        return this._caheTablas[tabla] = new dbTabla({
+            tabla: tabla,
+            connection: this,
+            callback: callback,
+            config: this.helpersConf()
+        }, verify)
+        //console.log(config)
+
+    }
+    /**
+    * metodo abstracto que escapara el texto sql
+    * @param {string} str - texto
+    * @return {string}
+    */
+    /*__escapeString(str)
+    {
+        return str
+    }*/
+
+
+    /**
+    * metodo 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
+    * }
+    * @param {string} table - nombre de la tabla
+    * @return {Promise}
+    */
+    _keysInTable(table) {
+        return new Promise((res) => {
+            res({
+                tabla: table,
+                colums: []
+            })
+        })
+    }
+    /**
+    * Verifica 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
+    *
+    * @param {string} tabla - nombre de la tabla
+    * @param {boolean} create - existencia en la base de datos
+    * @return {Promise}
+    */
+    inModel(tabla, create) {
+        return new Promise((res, rej) => {
+            if (!this.model(tabla)) {
+                rej()
+            } else {
+
+                if (create) {
+
+                    this._createTable(this.model(tabla))
+                        .then(res).catch(rej)
+                } else {
+                    res(this.model(tabla).getData())
+                }
+            }
+        })
+    }
+    /**
+    * crea una tabla en la base de datos apartir de un modelo
+    * si la tabla tiene claves foraneas intentara crear primero
+    * las tablas a las que apuntan
+    * @param {dbTablaModel} model - objeto del modelo
+    * @return {Promise}
+    */
+    _createTable(model) {
+
+        return new Promise((res, rej) => {
+            this._createdTables = {}
+            let rescursive = (foreingKey, i) => {
+
+                if (foreingKey[i] !== undefined) {
+                    try {
+                        this.tabla(foreingKey[i].reference, (t) => {
+                            rescursive(foreingKey, ++i)
+                        }, true)
+                    } catch (e) { rej(e) }
+                } else {
+
+                    this.query(model.sql(this)).then(() => {
+                        this._createdTables[model.tabla] = true
+                        this._initializeTable(model.tabla).then(() => {
+
+                            res(model.getData())
+                        }).catch(rej)
+                    }).catch(rej)
+                }
+            }
+            rescursive(model.foreingKey(), 0)
+        })
+    }
+    _initializeTable(tab) {
+        return new Promise(async (res) => {
+
+            let sql = new procesingSql(this.model(tab).getData(), this.helpersConf())
+            let init = this.model(tab).getData().init
+
+            if (init.length < 1) {
+                return res()
+            }
+            for (let item of init) {
+                await this.query(sql.insert(item))
+            }
+            res()
+
+        })
+
+    }
+}
+module.exports = Connect

package/lib/procesingSql.js

@@ -530,6 +530,7 @@ class prosesingSql {
         if (!(campos instanceof Array) || campos===[])
         {
             return  this.#helpers.campos([ this.tabla + ".*"])
+
         }
         return  this.#helpers.campos(campos)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtabla",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "interface de alto nivel para sql",
   "license": "MIT",
   "author": "enyerverfranco@gmail.com",
@@ -9,9 +9,15 @@
     "url": "git+https://github.com/ever23/dbtabla.git"
   },
   "main": "index.js",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
+  },
   "scripts": {
     "lint": "eslint  ./index.js ./lib",
-    "test": "node --test ./test/index.js"
+    "test": "node --test ./test/"
   },
   "keywords": [
     "sql",

package/refactor_dbtabla.js

@@ -1,36 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const libDir = 'c:/programacion/dbtabla/dbtabla/lib';
-
-// 1. Refactor Connect.js
-let connectFile = path.join(libDir, 'Connect.js');
-let connectCode = fs.readFileSync(connectFile, 'utf8');
-connectCode = connectCode.replace(/class Connect\s*\{/, 'class Connect {\n    #escapeChar;\n    #reserveIdentifiers;\n    #ar_aliased_tables;\n    #dbprefix;\n    #swap_pre;\n    #information_schema;\n    #models;\n    #caheTablas;\n    #createdTables;\n    #escapeString;');
-connectCode = connectCode.replace(/this\.__/g, 'this.#');
-connectCode = connectCode.replace(/^(\s*)__([a-zA-Z0-9_]+)\s*\(/gm, '$1#$2(');
-fs.writeFileSync(connectFile, connectCode);
-
-// 2. Refactor dbTabla.js
-let dbTablaFile = path.join(libDir, 'dbTabla.js');
-let dbTablaCode = fs.readFileSync(dbTablaFile, 'utf8');
-dbTablaCode = dbTablaCode.replace(/class dbTabla\s*\{/, 'class dbTabla {\n    #connection;\n    #lastSql;\n    #keys;\n    #callbackKey;\n    #config;\n\n    get lastSql() { return this.#lastSql; }\n');
-dbTablaCode = dbTablaCode.replace(/this\.__/g, 'this.#');
-dbTablaCode = dbTablaCode.replace(/^(\s*)__([a-zA-Z0-9_]+)\s*\(/gm, '$1#$2(');
-fs.writeFileSync(dbTablaFile, dbTablaCode);
-
-// 3. Refactor procesingSql.js
-let procesingSqlFile = path.join(libDir, 'procesingSql.js');
-let procesingSqlCode = fs.readFileSync(procesingSqlFile, 'utf8');
-procesingSqlCode = procesingSqlCode.replace(/class prosesingSql\s*\{/, 'class prosesingSql {\n    #helpers;');
-procesingSqlCode = procesingSqlCode.replace(/this\.__/g, 'this.#');
-procesingSqlCode = procesingSqlCode.replace(/^(\s*)__([a-zA-Z0-9_]+)\s*\(/gm, '$1#$2(');
-fs.writeFileSync(procesingSqlFile, procesingSqlCode);
-
-// 4. Refactor dbResult.js (read exposed property)
-let dbResultFile = path.join(libDir, 'dbResult.js');
-let dbResultCode = fs.readFileSync(dbResultFile, 'utf8');
-dbResultCode = dbResultCode.replace(/dbTabla\.__lastSql/g, 'dbTabla.lastSql');
-fs.writeFileSync(dbResultFile, dbResultCode);
-
-console.log('Refactoring completed successfully.');

package/test_results.txt

@@ -1,65 +0,0 @@
-
-> dbtabla@2.1.1 test
-> node --test ./test/index.js
-
-ÔûÂ test de dbTabla
-  ÔûÂ Test de la clase prosessingSql
-    Ô£ö verificacion de metodos (1.2094ms)
-    Ô£ö metodo busqueda (2.2858ms)
-    Ô£ö metodo select (1.1186ms)
-    Ô£ö metodo select (0.2998ms)
-    Ô£ö metodo insert (0.6902ms)
-    Ô£ö metodo update (0.4324ms)
-    Ô£ö metodo delete (0.3132ms)
-  Ô£ö Test de la clase prosessingSql (7.4947ms)
-  ÔûÂ Test de la clase Connect
-    Ô£ö verificacion de metodos (0.2097ms)
-    Ô£ö verificacion de modelos (2.2262ms)
-    Ô£ö verificacion de tabla (0.3958ms)
-  Ô£ö Test de la clase Connect (3.0674ms)
-  ÔûÂ Test de la clase dbRow
-    Ô£ö verificacion de metodos (0.2598ms)
-    Ô£û metodo update (1.4786ms)
-    Ô£ö metodo update sin claves primarias (0.367ms)
-    Ô£û metodo delete (0.6469ms)
-    Ô£ö metodo delete sin claves primarias (0.246ms)
-  Ô£û Test de la clase dbRow (3.3226ms)
-Ô£û test de dbTabla (14.5938ms)
-Ôä╣ tests 15
-Ôä╣ suites 4
-Ôä╣ pass 13
-Ôä╣ fail 2
-Ôä╣ cancelled 0
-Ôä╣ skipped 0
-Ôä╣ todo 0
-Ôä╣ duration_ms 168.9837
-
-Ô£û failing tests:
-
-test at test\dbRow.js:74:5
-Ô£û metodo update (1.4786ms)
-  AssertionError [ERR_ASSERTION]: "UPDATE test1 SET col1=2343 WHERE id=1 AND col1=234 AND col2='row';" == 'UPDATE test1 SET col1=2343 WHERE id=1;'
-      at C:\programacion\dbtabla\dbtabla\test\dbRow.js:90:20
-      at async Test.run (node:internal/test_runner/test:1125:7)
-      at async Suite.processPendingSubtests (node:internal/test_runner/test:787:7) {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: "UPDATE test1 SET col1=2343 WHERE id=1 AND col1=234 AND col2='row';",
-    expected: 'UPDATE test1 SET col1=2343 WHERE id=1;',
-    operator: '==',
-    diff: 'simple'
-  }
-
-test at test\dbRow.js:111:5
-Ô£û metodo delete (0.6469ms)
-  AssertionError [ERR_ASSERTION]: "DELETE FROM test1 WHERE id=1 AND col1=234 AND col2='row';" == 'DELETE FROM test1 WHERE id=1;'
-      at C:\programacion\dbtabla\dbtabla\test\dbRow.js:122:20
-      at async Test.run (node:internal/test_runner/test:1125:7)
-      at async Suite.processPendingSubtests (node:internal/test_runner/test:787:7) {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: "DELETE FROM test1 WHERE id=1 AND col1=234 AND col2='row';",
-    expected: 'DELETE FROM test1 WHERE id=1;',
-    operator: '==',
-    diff: 'simple'
-  }