lamix 4.2.17 → 4.2.19

package/README.md

@@ -117,15 +117,9 @@ const User = require('./models/User');
 const user = await User.create({ name: 'Alice', email: 'alice@example.com', password: 'secret' });
 
 # Fill & save (update)
-name = 'Alice Smith';  
-user.fill({ name })
+user.name = 'Alice Smith';  // you can also use user.fill({ name: 'Alice Smith' })
 await user.save();
 
-# Method 2 (update)
-const user = await User.findOrFail(param.id);
-const payload = req.body;  
-await user.update({ payload });
-
 # Find by primary key
 const user1 = await User.find(1);
 const user2 = await User.findOrFail(param.id);
@@ -170,7 +164,7 @@ const qb = User.query();
 const names = await User.query().select('id', 'name').get();
 
 # Aggregates
-const cnt = await User.query().count();     # count(*)
+const cnt = await User.query().count();          // count(*)
 const sumId = await User.query().sum('id');
 const avgId = await User.query().avg('id');
 const minId = await User.query().min('id');
@@ -187,12 +181,12 @@ const Pluckemails = await User.query().pluck('email');
 
 # Pagination
 const page1 = await User.query().paginate(1, 10);
-#page1 = { total, perPage, page, lastPage, data: [users...] }
+// page1 = { total, perPage, page, lastPage, data: [users...] }
 
 # Where In
 const usersIn = await User.query().whereIn('id', [1, 2, 3]).get();
 
-# Where Null / Not Null
+// Where Null / Not Null
 const withNull = await User.query().whereNull('deleted_at').get();
 const notNull = await User.query().whereNotNull('deleted_at').get();
 
@@ -225,7 +219,7 @@ const cached = await DB.cached('SELECT * FROM users WHERE id = ?', [5], 60000);
 #You can use relations:
 
 const user = await User.find(1);
-const posts = await user.posts().get();  # all posts for the user
+const posts = await user.posts().get();  // all posts for the user
 
 # Eager load in a query with Relations:
 const usersWithPosts = await User.query().with('posts').get();

package/lib/index.d.ts

@@ -294,15 +294,8 @@ export class QueryBuilder {
     _pushWhere(w: any): this;
     then(resolve: any, reject: any): Promise<Collection>;
     where(columnOrObject: any, operator: any, value: any, ...args: any[]): this;
+    andWhere(...args: any[]): this;
     orWhere(columnOrObject: any, operatorOrValue: any, value: any, ...args: any[]): this;
-    toSQL(): string;
-    /**************************************************************************
-     * TO SQL
-     **************************************************************************/
-    toSQL(): {
-        sql: string;
-        bindings: any[];
-    };
     whereRaw(sql: any, bindings?: any[]): this;
     orWhereRaw(sql: any, bindings?: any[]): this;
     whereColumn(a: any, op: any, b: any, ...args: any[]): this;
@@ -433,6 +426,13 @@ export class QueryBuilder {
         }[];
         fromRaw: any;
     };
+    /**************************************************************************
+     * TO SQL
+     **************************************************************************/
+    toSQL(): {
+        sql: string;
+        bindings: any[];
+    };
     toSQLJSON(): {
         sql: string;
         bindings: any[];
@@ -494,7 +494,7 @@ export class LamixSessionStore {
     cleanupInterval: any;
     logger: any;
     compress: any;
-    cache: LRUCache<{}, {}, unknown>;
+    cache: any;
     redisEnabled: boolean;
     redisRetryAt: number;
     redisCooldown: any;
@@ -548,11 +548,24 @@ export class BaseModel extends Model {
 }
 declare class SimpleCache {
     constructor(options?: {});
-    cache: LRUCache<{}, {}, unknown>;
-    get(k: any): {};
-    set(k: any, v: any, ttl?: number): void;
-    del(k: any): void;
+    cache: any;
+    get(key: any): any;
+    set(key: any, value: any, ttl?: any): void;
+    has(key: any): any;
+    delete(key: any): any;
     clear(): void;
+    /**
+     * Get value or compute + store it
+     * Supports async functions
+     */
+    getOrSet(key: any, fetchFn: any, ttl?: any): Promise<any>;
+    /**
+     * Basic cache stats
+     */
+    stats(): {
+        size: any;
+        calculatedSize: any;
+    };
 }
 import { AsyncLocalStorage } from "node:async_hooks";
 declare class HasManyThrough extends Relation {
@@ -612,5 +625,4 @@ declare class Relation {
     deleteBehavior: any;
     onDelete(behavior: any): this;
 }
-import { LRUCache } from "lru-cache";
 export {};

package/lib/index.js

@@ -3,11 +3,11 @@
 const util = require('util');
 const { performance } = require('perf_hooks');
 const { AsyncLocalStorage } = require('async_hooks');
+require('dotenv').config();
 const session = require('express-session');
 const Redis = require('ioredis');
-const LRUCache  = require('lru-cache');
+const { LRUCache } = require('lru-cache');
 const zlib = require('zlib');
-require('dotenv').config();
 
 /* ---------------- Utilities ---------------- */
 
@@ -29,37 +29,76 @@ class DBError extends Error {
 }
 
 /* ---------------- Cache ---------------- */
-
 class SimpleCache {
   constructor(options = {}) {
+    const {
+      max = 1000,            // max number of items
+      ttl = 0,               // default TTL (ms)
+      maxSize,               // optional size-based eviction
+      sizeCalculation,       // function(value, key)
+    } = options;
+
     this.cache = new LRUCache({
-      max: options.max || 1000,          // max number of items
-      ttlAutopurge: true,                // auto-remove expired entries
+      max,
+      ttl,
+      ttlAutopurge: true,
+      maxSize,
+      sizeCalculation,
+      allowStale: false,
+      updateAgeOnGet: false,
     });
   }
 
-  get(k) {
-    const v = this.cache.get(k);
-    return v === undefined ? null : v;
+  get(key) {
+    const value = this.cache.get(key);
+    return value === undefined ? null : value;
   }
 
-  set(k, v, ttl = 0) {
-    if (ttl > 0) {
-      this.cache.set(k, v, { ttl });
+  set(key, value, ttl = null) {
+    if (ttl !== null) {
+      this.cache.set(key, value, { ttl });
     } else {
-      this.cache.set(k, v);
+      this.cache.set(key, value);
     }
   }
 
-  del(k) {
-    this.cache.delete(k);
+  has(key) {
+    return this.cache.has(key);
+  }
+
+  delete(key) {
+    return this.cache.delete(key);
   }
 
   clear() {
     this.cache.clear();
   }
+
+  /**
+   * Get value or compute + store it
+   * Supports async functions
+   */
+  async getOrSet(key, fetchFn, ttl = null) {
+    const existing = this.get(key);
+    if (existing !== null) return existing;
+
+    const value = await fetchFn();
+    this.set(key, value, ttl);
+    return value;
+  }
+
+  /**
+   * Basic cache stats
+   */
+  stats() {
+    return {
+      size: this.cache.size,
+      calculatedSize: this.cache.calculatedSize,
+    };
+  }
 }
 
+
 /* ---------------- Grammar ---------------- */
 
 class Grammar {
@@ -85,7 +124,7 @@ class DB {
   static config = null;
   static pool = null;
 
-  static cache = new SimpleCache();
+  static cache = new SimpleCache({ max: 1000, ttl: 60_000 });
   static retryAttempts = 1;
 
   static eventHandlers = { query: [], error: [], reconnect: [] };
@@ -1308,6 +1347,10 @@ class QueryBuilder {
     });
   }
 
+  andWhere(...args) {
+    return this.where(...args);
+  }
+
   orWhere(columnOrObject, operatorOrValue, value) {
     if (typeof columnOrObject === 'object' && columnOrObject !== null) {
       let query = this;
@@ -1336,15 +1379,14 @@ class QueryBuilder {
   }
 
   // Example method to generate SQL
-  toSQL() {
-    if (!this.wheres.length) return '';
-    const sql = this.wheres.map((w, i) => {
-      const prefix = i === 0 ? '' : ` ${w.boolean} `;
-      return `${prefix}\`${w.column}\` ${w.operator} ?`;
-    }).join('');
-    return 'WHERE ' + sql;
-  }
-
+  // toSQL() {
+  //   if (!this.wheres.length) return '';
+  //   const sql = this.wheres.map((w, i) => {
+  //     const prefix = i === 0 ? '' : ` ${w.boolean} `;
+  //     return `${prefix}\`${w.column}\` ${w.operator} ?`;
+  //   }).join('');
+  //   return 'WHERE ' + sql;
+  // }
 
   whereRaw(sql, bindings = []) {
     return this._pushWhere({
@@ -3451,7 +3493,9 @@ class Model {
   // INSERT – validation first
   // ──────────────────────────────
   async saveNew(attrs) {
-    if (!this._exists && !Object.keys(this._attributes).length) {
+    this._attributes = { ...attrs }; 
+    
+    if (!Object.keys(this._attributes).length) {
       throw new DBError('Cannot save empty model', {
         model: this.constructor.name
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lamix",
-  "version": "4.2.17",
+  "version": "4.2.19",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib",
   "type": "commonjs",
@@ -34,7 +34,7 @@
     "lru-cache": "^11.2.5",
     "ioredis": "^5.9.2",
     "chalk": "^4.1.2",
-    "dotenv": "^17.2.4"
+    "dotenv": "^17.2.4 "
   },
   "keywords": [
     "lamix",