backend-plus 2.7.0-beta.12 → 2.7.0-beta.14

package/for-client/my-tables.js

@@ -687,7 +687,7 @@ myOwn.tableGrid = function tableGrid(tableName, mainElement, opts){
                         depot.manager.displayAsDeleted(depot, force ? 'change-ff' : 'unknown');
                         if (myOwn.config.config['grid-row-retain-moved-or-deleted']) {
                             if(!depot['$refreshed']){
-                                grid.retrieveRowAndRefresh(depot,{retrieveIgnoringWhere:true})
+                                grid.retrieveRowAndRefresh(depot,{retrieveWithBroadWhere:true})
                                 depot['$refreshed'] = true
                             }
                         }
@@ -2435,7 +2435,7 @@ myOwn.TableGrid.prototype.displayGrid = function displayGrid(){
                 return {fieldName:fieldName, value:depot.primaryKeyValues[i]};
             }),
             pick:grid.def.pick,
-            retrieveIgnoringWhere: opts?opts.retrieveIgnoringWhere:false
+            retrieveWithBroadWhere : opts?.retrieveWithBroadWhere ?? false
         }).then(function(result){
             grid.depotRefresh(depot,{updatedRow:result[0], sendedForUpdate:{}}, opts);
         })

package/lib/backend-plus.d.ts

@@ -284,10 +284,12 @@ export type TableDefinition = EditableDbDefinition & {
     primaryKey:string[]
     refrescable?: boolean
     sql?:{
+        select?: string[]
         primaryKey4Delete?:string[]
         isTable?:boolean
         from?:string
         where?:string
+        broadWhere?:string
         postCreateSqls?:string
         skipEnance?: boolean
         isReferable?: boolean
@@ -338,6 +340,7 @@ export type TableDefinition = EditableDbDefinition & {
     policy?:string
     firstDisplayCount?:number
     firstDisplayOverLimit?:number
+    forInsertOnlyMode?:boolean
     description?:MarkdownDoc
     exportJsonFieldAsColumns?:string
     importCuidado?:boolean
@@ -350,6 +353,7 @@ export type TableDefinition = EditableDbDefinition & {
     functionDef?:{
         parameters?:ProcedureParameter[]
     }
+
 }
 export type TableDefinitionInternal = RequireSome<TableDefinition,
     'allow'|'sql'

package/lib/backend-plus.js

@@ -115,9 +115,6 @@ function md5(text){
 const DEFAULT_ITERATIONS = 4096;
 const HASH_ALGORITHM = 'sha256';
 
-// primera version de scram sha 256. El Verifier completo tenía 64 bytes.
-const LEGACY_KEY_LENGTH = 64;
-
 // Formato nuevo/PG-Compatible: El Client Key tiene 32 bytes (SHA-256).
 const SCRAM_KEY_LENGTH = 32;
 
@@ -215,57 +212,6 @@ async function verifyScramPG(password, storedScramString) {
     return storedKeyMatch && serverKeyMatch;
 }
 
-/**
- * Verifica una contraseña contra el hash SCRAM Legacy (64 bytes).
- * Formato Legacy: SCRAM-SHA-256$<iteraciones>:<Salt>$<Verifier(64 bytes)>
- * @param {string} password - Contraseña en texto plano.
- * @param {string} storedScramString - Cadena SCRAM Legacy.
- * @returns {Promise<boolean>} True si la contraseña es válida.
- */
-async function verifyScramLegacy(password, storedScramString) {
-    if (!storedScramString.startsWith('SCRAM-SHA-256$')) {
-        // No es formato SCRAM. Debe ser MD5 u otro algoritmo.
-        return false;
-    }
-
-    // Parsea la cadena SCRAM
-    // Ejemplo: SCRAM-SHA-256$4096:SALT_BASE64$VERIFIER_BASE64
-    const parts = storedScramString.split('$');
-    if (parts.length !== 3) {
-        throw new Error('Formato SCRAM almacenado inválido.');
-    }
-
-    // Obtiene iteraciones y salt de la segunda parte (ej: '4096:SALT_BASE64')
-    const [storedIterations, storedSalt] = parts[1].split(':');
-    const storedVerifier = parts[2];
-
-    if (!storedSalt || !storedVerifier || isNaN(parseInt(storedIterations))) {
-        throw new Error('Datos de SCRAM incompletos o malformados.');
-    }
-
-    const iterations = parseInt(storedIterations);
-
-    // Deriva la clave de la contraseña ingresada
-    const generatedVerifierBuffer = await deriveKey(
-        password,
-        storedSalt,
-        iterations,
-        LEGACY_KEY_LENGTH
-    );
-    const generatedVerifier = bufferToBase64(generatedVerifierBuffer);
-
-    // Compara de manera segura contra el Verificador Almacenado
-    const storedVerifierBuffer = Buffer.from(storedVerifier, 'base64');
-    const generatedVerifierBufferFromBase64 = Buffer.from(generatedVerifier, 'base64');
-
-    // Usa crypto.timingSafeEqual para evitar ataques de temporización
-    if (generatedVerifierBufferFromBase64.length !== storedVerifierBuffer.length) {
-        return false;
-    }
-
-    return crypto.timingSafeEqual(generatedVerifierBufferFromBase64, storedVerifierBuffer);
-}
-
 var dist=regexpDistCheck.test(packagejson.main)?'dist/':'';
 
 /**
@@ -1283,7 +1229,6 @@ AppBackend.prototype.start = function start(opts){
                             done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                             return
                         }else{
-                            let needsMigration = false;
                             const user = data.row;
                             if(!user[passFieldName]){
                                 done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
@@ -1291,34 +1236,20 @@ AppBackend.prototype.start = function start(opts){
                             }
                             const usaScramSha256 = user[passFieldName].startsWith('SCRAM-SHA-256$')
                             if (usaScramSha256){
-                                let isScramValid = false;
-                                // 1. Intento con formato PG-Compatible (Nuevo)
-                                if(await verifyScramPG(password, user[passFieldName])){
-                                    isScramValid = true;
-                                }
-
-                                // 2. Intento con formato Legacy (64 bytes)
-                                else if(await verifyScramLegacy(password, user[passFieldName])){
-                                    isScramValid = true;
-                                    needsMigration = true;
-                                }
-                                if(!isScramValid){
+                                if(!await verifyScramPG(password, user[passFieldName])){
                                     done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                                     return
                                 }
                             }else{
                                 if (md5(password+username.toLowerCase()) === user[passFieldName]){
-                                    needsMigration = true;
+                                    if (be.config.log["pass-migration"]) console.log('Ejecutando migración a SCRAM...');
+                                    await updatePassword({client, username, password, setUpdateDate:false, errorIfNoResult:true});
+                                    if (be.config.log["pass-migration"]) console.log('Migración completada.');
                                 }else{
                                     done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                                     return
                                 }
                             }
-                            if(needsMigration){
-                                if (be.config.log["pass-migration"]) console.log('Ejecutando migración a SCRAM...');
-                                await updatePassword({client, username, password, setUpdateDate:false, errorIfNoResult:true});
-                                if (be.config.log["pass-migration"]) console.log('Migración completada.');
-                            }
                         }
                         //continua validando
                         if(data.rowCount==1){
@@ -1388,9 +1319,6 @@ AppBackend.prototype.start = function start(opts){
                 if (oldPassword !== false) {
                     if (storedHash.startsWith('SCRAM-SHA-256$')) {//Intento SCRAM-SHA-256
                         ok = await verifyScramPG(oldPassword, storedHash);
-                        if (!ok) {
-                            ok = await verifyScramLegacy(oldPassword, storedHash);
-                        }
                     } else { //Intento MD5
                         const md5Hash = md5(oldPassword + username.toLowerCase());
                         ok = (md5Hash === storedHash);

package/lib/procedures-table.js

@@ -10,6 +10,7 @@ var likeAr=require('like-ar');
 const f = require('session-file-store');
 const { expected } = require('cast-error');
 const bestGlobals = require('best-globals');
+const { AppBackend } = require('backend-plus');
 
 const PANIC_IMPORT = true;
 
@@ -85,26 +86,29 @@ ProcedureTables = [
             {name: 'fixedFields', defaultValue:[]},
             {name: 'paramfun', defaultValue:[]},
             {name: 'pick', defaultValue:'', encoding:'plain'},
-            {name: 'retrieveIgnoringWhere', defaultValue:false}
+            {name: 'retrieveWithBroadWhere', defaultValue:false}
         ],
         coreFunction:
         /**
         *
         * @param {*} context
-        * @param {{table:string, fixedFields:{fieldName:string, value:any, range?:string, until?:string}[], paramfun:string[], pick:string, retrieveIgnoringWhere:boolean}} parameters
+        * @param {{table:string, fixedFields:{fieldName:string, value:any, range?:string, until?:string}[], paramfun:Record<string, string>, pick:string, retrieveWithBroadWhere:boolean}} parameters
         */
         async function tableDatum(context, parameters){
+            /**  @type {AppBackend} */
             var be=context.be;
             var tableName=parameters.table;
-            var defTable=be.tableStructures[tableName];
-            if(!defTable){
+            var defTableFun=be.tableStructures[tableName];
+            if(!defTableFun){
                 throw new Error('no table def for '+tableName+' (in table_data)')
             }
-            defTable=defTable(context);
+            var defTable=defTableFun(context);
             /** @type {string} */
             var sql;
             var queryValues=[];
+            /** @type {string[]} */
             var specialFixedClause=[];
+            /** @type {string[]} */
             var fixedClausule=[];
             if(defTable.functionDef){
                 parameters.fixedFields.forEach(function(pair, iPair){
@@ -155,10 +159,19 @@ ProcedureTables = [
                     fixedClausule.push(exprClausule)
                 }
             });
+
+            const getBaseWhere = (defTable, params) => {
+                if (params?.retrieveWithBroadWhere && defTable.sql?.broadWhere) return defTable.sql.broadWhere;
+                if (params?.retrieveWithBroadWhere) console.warn("No broadWhere found for retrieveWithBroadWhere. Using default configuration.");
+                return defTable.sql?.where || (defTable.allow?.select && !defTable.forInsertOnlyMode ? 'true' : 'false');
+            };
+
+            const whereCondition = getBaseWhere(defTable, parameters) + fixedClausule.join("");
+
             /** @type {string} */
             var sql="SELECT "+[...defTable.sql.select].join(', ')+
                 "\n FROM "+defTable.sql.from+
-                "\n WHERE "+((parameters.retrieveIgnoringWhere?'true':defTable.sql.where)||(defTable.allow.select && !defTable.forInsertOnlyMode?'true':'false'))+fixedClausule.join("")+
+                "\n WHERE "+whereCondition+
                 // " ORDER BY "+defTable.primaryKey.map(be.db.quoteIdent.bind(be.db)).join(',')
                 "\n ORDER BY "+(defTable.sql.orderBy||defTable.primaryKey).map(function(fieldName){ return be.db.quoteIdent(fieldName); }).join(',')
             if(specialFixedClause.length){

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "backend-plus",
   "description": "Backend for the anti Pareto rule",
-  "version": "2.7.0-beta.12",
+  "version": "2.7.0-beta.14",
   "author": "Codenautas <codenautas@googlegroups.com>",
   "license": "MIT",
   "repository": "codenautas/backend-plus",