lamix 4.2.26 → 4.2.27

package/README.md

@@ -173,6 +173,8 @@ const maxId = await User.query().max('id');
 # status a column (returns status of boolean values)
 const usersAll = await User.all();
 const users = await User.query().where('status', true).get();
+# Randomize a column (returns Random values without any order)
+const users = await User.query().where('status', true).orderByRaw('RAND()').get();
 const usersorderbyid = await User.query().where('status', true).orderBy('id', 'desc').get();
 const usersorderbycreateAt = await User.query().where('status', true).orderBy('created_at', 'desc').get();
 

package/lib/@types/index.d.ts

@@ -333,6 +333,10 @@ export class QueryBuilder {
     having(column: any, operatorOrValue: any, value: any, ...args: any[]): this;
     orHaving(column: any, operatorOrValue: any, value: any, ...args: any[]): this;
     _pushHaving(column: any, op: any, value: any, bool: any): this;
+    /**************************************************************************
+     * ORDER BY RAW
+     **************************************************************************/
+    orderByRaw(rawSql: any): this;
     /**************************************************************************
      * ORDER / LIMIT
      **************************************************************************/
@@ -395,7 +399,7 @@ export class QueryBuilder {
     decrement(col: any, by?: number): Promise<any>;
     delete(): Promise<any>;
     truncate(): Promise<boolean>;
-    _compileWhereOnly(): string;
+    _compileWhereOnly(allowEmpty?: boolean): string;
     /**************************************************************************
      * EAGER LOAD (unchanged except robust checks)
      **************************************************************************/

package/lib/index.js

@@ -818,7 +818,7 @@ class Validator {
     // For strings or arrays, use length
     if (typeof val === 'string' || Array.isArray(val)) {
       if (val.length < limit) {
-        this.addError(field, 'min', `${field} must be at least ${limit} characters.`);
+        this.addError(field, this.msg(field, 'min', `${field} must be at least ${limit} characters.`));
       }
     }
     // For numbers, compare numerically
@@ -853,8 +853,15 @@ class Validator {
   validateConfirmed(field) {
     const value = this.data[field];
     const confirm = this.data[field + '_confirmation'];
-    if (value !== confirm) {
-      this.addError(field, this.msg(field, 'confirmed', `${field} confirmation does not match.`));
+    if (!value) return;
+    
+    const v1 = String(value).trim();
+    const v2 = String(confirm ?? '').trim();
+    if (v1 !== v2) {
+      this.addError(
+        field,
+        this.msg(field, 'confirmed', `${field} confirmation does not match.`)
+      );
     }
   }
 
@@ -1011,14 +1018,31 @@ class Validator {
     }
   }
 
-    validatePhone(field) {
+  validatePhone(field) {
     const val = this.data[field];
     if (!val) return;
-    const s = String(val);
-    const phoneRegex = /^(0\d{9}|\+[1-9]\d{6,14})$/;
-    if (!phoneRegex.test(s)) {
-      this.addError(field, this.msg(field, 'phone', `${field} must be a valid phone number.`));
+    let cleaned = String(val).replace(/[\s\-()]/g, '');
+    /*
+      Allow:
+      - +countrycode + number (8–15 digits total)
+      - numbers starting with 0
+      - numbers starting with country code (no +)
+      - 7–15 digits total
+    */
+    const phoneRegex = /^(\+?\d{8,15}|0\d{8,14})$/;
+
+    if (!phoneRegex.test(cleaned)) {
+      this.addError(
+        field,
+        this.msg(field, 'phone', `${field} must be a valid phone number.`)
+      );
+      return;
     }
+
+    // if (!cleaned.startsWith('+')) {
+    //   cleaned = '+' + cleaned;
+    // }
+    // this.data[field] = cleaned;
   }
 
   validateAlpha(field) {
@@ -1481,7 +1505,7 @@ class Paginator {
 }
 
 
-const VALID_OPERATORS = ['=', '<', '<=', '>', '>=', '<>', '!=', 'LIKE', 'ILIKE'];
+const VALID_OPERATORS = ['=', '<', '<=', '>', '>=', '<>', '!=', 'LIKE', 'ILIKE', 'NOT IN'];
 /******************************************************************************
  * QueryBuilder (Bug-Free)
  *****************************************************************************/
@@ -1513,7 +1537,7 @@ class QueryBuilder {
 
   // Helper to normalize operator
   _normalizeOperator(operator) {
-    const op = operator ? operator.toUpperCase() : '='
+    let op = operator ? operator.toUpperCase() : '=';
     if (!VALID_OPERATORS.includes(op)) {
       throw new DBError('Invalid SQL operator', {
         operator,
@@ -1522,14 +1546,10 @@ class QueryBuilder {
       });
     }
 
-    // Convert ILIKE to proper operator for MySQL
-    if (op === 'ILIKE' && this.dialect === 'mysql') {
-      return 'LIKE';
-    }
-
+    // Convert ILIKE to LIKE for MySQL
+    if (op === 'ILIKE' && this.dialect === 'mysql') op = 'LIKE';
     return op;
   }
-
   /**************************************************************************
    * BASIC CONFIG
    **************************************************************************/
@@ -1619,7 +1639,7 @@ class QueryBuilder {
 
     const op = this._normalizeOperator(operator);
 
-    // For MySQL + LIKE case-insensitive, wrap with LOWER()
+    // Use LOWER() only if original operator was ILIKE on MySQL
     const useLower = this.dialect === 'mysql' && operator.toUpperCase() === 'ILIKE';
     return this._pushWhere({
       type: 'basic',
@@ -1744,8 +1764,7 @@ class QueryBuilder {
   /** COMPLETELY FIXED VERSION */
   whereNot(column, operatorOrValue, value) {
     if (typeof column === 'object' && column !== null) {
-      for (const [k, v] of Object.entries(column))
-        this.whereNot(k, v);
+      for (const [k, v] of Object.entries(column)) this.whereNot(k, v);
       return this;
     }
 
@@ -1760,11 +1779,13 @@ class QueryBuilder {
     if (operator === '=') operator = '!=';
     if (operator.toUpperCase() === 'IN') operator = 'NOT IN';
 
+    const op = this._normalizeOperator(operator);
+
     return this._pushWhere({
       type: 'basic',
       not: true,
       column,
-      operator,
+      operator: op,
       value: val,
       bindings: [val]
     });
@@ -1906,6 +1927,22 @@ class QueryBuilder {
     return this;
   }
 
+  /**************************************************************************
+   * ORDER BY RAW
+   **************************************************************************/
+  orderByRaw(rawSql) {
+    if (typeof rawSql !== 'string' || !rawSql.trim()) {
+      throw new DBError('orderByRaw expects a non-empty string', {
+        method: 'orderByRaw',
+        rawSql
+      });
+    }
+
+    // Push as a special type
+    this._orders.push({ raw: rawSql });
+    return this;
+  }
+
   /**************************************************************************
    * ORDER / LIMIT
    **************************************************************************/
@@ -2092,7 +2129,7 @@ class QueryBuilder {
       parts.push(
         'ORDER BY ' +
         this._orders
-          .map(([c, d]) => `${escapeId(c)} ${d}`)
+          .map(o => (Array.isArray(o) ? `${escapeId(o[0])} ${o[1]}` : o.raw))
           .join(', ')
       );
     }
@@ -2558,7 +2595,13 @@ class QueryBuilder {
     }
   }
 
-  _compileWhereOnly() {
+  _compileWhereOnly(allowEmpty = false) {
+    if (!allowEmpty && !this._wheres.length) {
+      throw new DBError('Unsafe query without WHERE clause', {
+        table: this.table,
+        method: '_compileWhereOnly'
+      });
+    }
     const w = this._compileWheres();
     return w ? w : '';
   }
@@ -2597,10 +2640,9 @@ class QueryBuilder {
    **************************************************************************/
   _clone() {
     const c = new QueryBuilder(this.table, this.modelClass);
-
     c.tableAlias = this.tableAlias;
     c._select = [...this._select];
-    c._joins = JSON.parse(JSON.stringify(this._joins));
+    c._joins = this._joins.map(j => ({ ...j })); // shallow copy sufficient
     c._group = [...this._group];
     c._orders = [...this._orders];
     c._limit = this._limit;
@@ -2611,17 +2653,12 @@ class QueryBuilder {
     c._ignoreSoftDeletes = this._ignoreSoftDeletes;
     c._fromRaw = this._fromRaw;
 
-    // rehydrate nested queries
+    // Rehydrate wheres, CTEs, unions
     c._wheres = this._rehydrateWheres(this._wheres);
-
-    // rehydrate CTEs
     c._ctes = this._rehydrateCTEs(this._ctes);
-
-    // rehydrate unions
     c._unions = this._rehydrateUnions(this._unions);
 
-    // having is simple
-    c._having = JSON.parse(JSON.stringify(this._having));
+    c._having = this._having.map(h => ({ ...h }));
 
     return c;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lamix",
-  "version": "4.2.26",
+  "version": "4.2.27",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib/index.js",
   "type": "commonjs",
@@ -26,14 +26,14 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.30",
+    "chalk": "^4.1.2",
     "typescript": "^5.4.5"
   },
   "dependencies": {
     "bcrypt": "^6.0.0",
+    "dotenv": "^17.2.4 ",
     "express-session": "^1.19.0",
-    "lru-cache": "^11.2.5",
-    "chalk": "^4.1.2",
-    "dotenv": "^17.2.4 "
+    "lru-cache": "^11.2.5"
   },
   "keywords": [
     "lamix",