lamix 4.2.19 → 4.2.21

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const fs = require('fs');
 const path = require('path');

package/lib/index.d.ts

@@ -67,6 +67,7 @@ export class Model {
     static whereNot(...args: any[]): QueryBuilder;
     static whereNotIn(col: any, arr: any): QueryBuilder;
     static whereNull(col: any): QueryBuilder;
+    static filter(...args: any[]): QueryBuilder;
     static find(value: any): Promise<any>;
     static findOrFail(value: any): Promise<any>;
     static findBy(col: any, value: any): Promise<any>;
@@ -212,7 +213,15 @@ export class Collection extends Array<any> {
     clone(): Collection;
     each(fn: any): Promise<this>;
     mapAsync(fn: any): Promise<Collection>;
-    where(key: any, value: any): Collection;
+    /**
+     * Enhanced filter:
+     * - filter(fn)
+     * - filter({ key: value })
+     * - filter('key', value)
+     * - filter('key', '>', value)
+     */
+    filter(condition: any, operator?: any, value?: any): Collection;
+    where(key: any, operator: any, value?: any): Collection;
     whereNot(key: any, value: any): Collection;
     filterNull(): Collection;
     onlyKeys(keys: any): Collection;
@@ -492,26 +501,12 @@ export class LamixSessionStore {
     constructor(options?: {});
     ttl: any;
     cleanupInterval: any;
-    logger: any;
-    compress: any;
-    cache: any;
-    redisEnabled: boolean;
-    redisRetryAt: number;
-    redisCooldown: any;
-    redis: any;
-    _safeCb(cb: any, err: any, result?: any): void;
-    _hasSessionModel(): boolean;
-    _canUseRedis(): boolean;
-    _markRedisFailure(err: any): void;
-    _serialize(data: any): string;
-    _deserialize(raw: any): any;
-    _checkRedisHealth(): Promise<void>;
-    get(sid: any, cb: any): Promise<void>;
+    get(sid: any, cb: any): Promise<any>;
     set(sid: any, sessionData: any, cb: any): Promise<void>;
     destroy(sid: any, cb: any): Promise<void>;
-    touch(sid: any, sessionData: any, cb: any): Promise<void>;
+    touch(sid: any, sessionData: any, cb: any): Promise<any>;
     _startCleanup(): void;
-    _cleanupTimer: any;
+    _cleanupTimer: NodeJS.Timeout;
 }
 export class BaseModel extends Model {
     static passwordField: string;
@@ -548,23 +543,36 @@ export class BaseModel extends Model {
 }
 declare class SimpleCache {
     constructor(options?: {});
-    cache: any;
-    get(key: any): any;
-    set(key: any, value: any, ttl?: any): void;
-    has(key: any): any;
-    delete(key: any): any;
-    clear(): void;
+    cache: LRUCache<{}, {}, unknown>;
+    /**
+     * Get cached value
+     * @param {string} key
+     * @returns {*} value or null
+     */
+    get(key: string): any;
     /**
-     * Get value or compute + store it
-     * Supports async functions
+     * Set cache value
+     * @param {string} key
+     * @param {*} value
+     * @param {number} ttl Optional TTL in ms
      */
-    getOrSet(key: any, fetchFn: any, ttl?: any): Promise<any>;
+    set(key: string, value: any, ttl?: number): void;
+    /**
+     * Delete a key
+     * @param {string} key
+     */
+    del(key: string): void;
+    /**
+     * Clear entire cache
+     */
+    clear(): void;
     /**
-     * Basic cache stats
+     * Get cache stats (optional utility)
      */
     stats(): {
-        size: any;
-        calculatedSize: any;
+        size: number;
+        calculatedSize: number;
+        maxSize: number;
     };
 }
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -625,4 +633,5 @@ declare class Relation {
     deleteBehavior: any;
     onDelete(behavior: any): this;
 }
+import { LRUCache } from "lru-cache";
 export {};

package/lib/index.js

@@ -5,7 +5,6 @@ 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 zlib = require('zlib');
 
@@ -32,68 +31,75 @@ class DBError extends Error {
 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)
+      maxSizeMB = 50,          // total memory cap
+      defaultTTL = 1000 * 60 * 5, // 5 minutes
     } = options;
 
     this.cache = new LRUCache({
-      max,
-      ttl,
+      maxSize: maxSizeMB * 1024 * 1024, // convert MB → bytes
+      ttl: defaultTTL,
       ttlAutopurge: true,
-      maxSize,
-      sizeCalculation,
       allowStale: false,
-      updateAgeOnGet: false,
+
+      // Estimate memory usage per entry
+      sizeCalculation: (value, key) => {
+        try {
+          return Buffer.byteLength(JSON.stringify(value));
+        } catch (err) {
+          // fallback small size if stringify fails
+          return 1024;
+        }
+      },
     });
   }
 
+  /**
+   * Get cached value
+   * @param {string} key
+   * @returns {*} value or null
+   */
   get(key) {
     const value = this.cache.get(key);
     return value === undefined ? null : value;
   }
 
-  set(key, value, ttl = null) {
-    if (ttl !== null) {
+  /**
+   * Set cache value
+   * @param {string} key
+   * @param {*} value
+   * @param {number} ttl Optional TTL in ms
+   */
+  set(key, value, ttl = 0) {
+    if (ttl > 0) {
       this.cache.set(key, value, { ttl });
     } else {
       this.cache.set(key, value);
     }
   }
 
-  has(key) {
-    return this.cache.has(key);
-  }
-
-  delete(key) {
-    return this.cache.delete(key);
-  }
-
-  clear() {
-    this.cache.clear();
+  /**
+   * Delete a key
+   * @param {string} key
+   */
+  del(key) {
+    this.cache.delete(key);
   }
 
   /**
-   * Get value or compute + store it
-   * Supports async functions
+   * Clear entire cache
    */
-  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;
+  clear() {
+    this.cache.clear();
   }
 
   /**
-   * Basic cache stats
+   * Get cache stats (optional utility)
    */
   stats() {
     return {
       size: this.cache.size,
       calculatedSize: this.cache.calculatedSize,
+      maxSize: this.cache.maxSize,
     };
   }
 }
@@ -124,7 +130,7 @@ class DB {
   static config = null;
   static pool = null;
 
-  static cache = new SimpleCache({ max: 1000, ttl: 60_000 });
+  static cache = new SimpleCache({ maxSizeMB: 500, defaultTTL: 1000 * 60 * 2});
   static retryAttempts = 1;
 
   static eventHandlers = { query: [], error: [], reconnect: [] };
@@ -929,16 +935,78 @@ class Collection extends Array {
   // -------------------------
   // Filtering
   // -------------------------
-  where(key, value) {
-    return new Collection(this.filter(item => item?.[key] === value));
+  /**
+   * Enhanced filter:
+   * - filter(fn)
+   * - filter({ key: value })
+   * - filter('key', value)
+   * - filter('key', '>', value)
+   */
+  filter(condition, operator = null, value = null) {
+
+    // 1️⃣ Callback style
+    if (typeof condition === 'function') {
+      return new Collection(
+        Array.prototype.filter.call(this, condition)
+      );
+    }
+
+    // 2️⃣ Object style
+    if (typeof condition === 'object' && !Array.isArray(condition)) {
+      return new Collection(
+        Array.prototype.filter.call(this, item =>
+          Object.entries(condition).every(
+            ([k, v]) => item?.[k] === v
+          )
+        )
+      );
+    }
+
+    // 3️⃣ Key/value or key/operator/value
+    if (typeof condition === 'string') {
+
+      // If only 2 args → assume "="
+      if (value === null) {
+        value = operator;
+        operator = '=';
+      }
+
+      return new Collection(
+        Array.prototype.filter.call(this, item => {
+          const field = item?.[condition];
+
+          switch (operator) {
+            case '=':
+            case '==':  return field == value;
+            case '===': return field === value;
+            case '!=':  return field != value;
+            case '!==': return field !== value;
+            case '>':   return field > value;
+            case '>=':  return field >= value;
+            case '<':   return field < value;
+            case '<=':  return field <= value;
+            case 'in':     return Array.isArray(value) && value.includes(field);
+            case 'not in': return Array.isArray(value) && !value.includes(field);
+            default: return false;
+          }
+        })
+      );
+    }
+
+    return new Collection();
+  }
+
+  // Laravel-style aliases
+  where(key, operator, value = null) {
+    return this.filter(key, operator, value);
   }
 
   whereNot(key, value) {
-    return new Collection(this.filter(item => item?.[key] !== value));
+    return this.filter(item => item?.[key] !== value);
   }
 
   filterNull() {
-    return new Collection(this.filter(v => v !== null && v !== undefined));
+    return this.filter(v => v !== null && v !== undefined);
   }
 
   onlyKeys(keys) {
@@ -3217,22 +3285,31 @@ class Model {
   // ──────────────────────────────
   static async all() { return await this.query().get(); }
   static where(...args) { return this.query().where(...args); }
+  // static filter(...args) { return this.query().where(...args); }
   static whereIn(col, arr) { return this.query().whereIn(col, arr); }
   static whereNot(...args) { return this.query().whereNot(...args); }
   static whereNotIn(col, arr) { return this.query().whereNotIn(col, arr); }
   static whereNull(col) { return this.query().whereNull(col); }
 
+  static filter(...args) {
+    const qb = this.query();
+    if (args.length === 1 && typeof args[0] === 'object' && !Array.isArray(args[0])) {
+      for (const [key, value] of Object.entries(args[0])) {
+        qb.where(key, value);
+      }
+      return qb;
+    }
+    return qb.where(...args);
+  }
+
   static async find(value) {
     if (value === undefined || value === null) return null;
-
     const query = this.query();
-
     // If numeric → try primary key first
     if (!isNaN(value)) {
       const row = await query.where(this.primaryKey, value).first();
       if (row) return row;
     }
-
     // Fallback or non-numeric → try slug
     return await this.query()
       .where(this.slugKey, value)
@@ -3965,155 +4042,79 @@ class Session extends Model {
 let SessionModel = null;
 
 try {
-  // If this throws, DB-backed sessions are simply disabled
   SessionModel = Session;
 } catch (err) {
   SessionModel = null;
 }
 
 /* -------------------- Store -------------------- */
+const { promisify } = require('util');
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
 class LamixSessionStore extends session.Store {
   constructor(options = {}) {
     super();
 
-    this.ttl = options.ttl || 86400;
+    this.ttl = options.ttl || 86400; // seconds
     this.cleanupInterval = options.cleanupInterval || 60000;
-    this.logger = options.logger || console;
-    this.compress = options.compress ?? true;
-
-    /* -------- In-memory cache -------- */
-    this.cache = new LRUCache({
-      max: options.cacheSize || 1000,
-      ttl: options.cacheTTL || 60000,
-    });
-
-    /* -------- Redis -------- */
-    this.redisEnabled = false;
-    this.redisRetryAt = 0;
-    this.redisCooldown = options.redisCooldown || 30000;
-
-    if (options.redis) {
-      this.redis =
-        options.redis instanceof Redis
-          ? options.redis
-          : new Redis(options.redis);
-
-      this._checkRedisHealth();
-    }
 
     this._startCleanup();
   }
 
-  /* -------------------- Safety Helpers -------------------- */
-  _safeCb(cb, err, result = null) {
-    try {
-      cb(err, result);
-    } catch (e) {
-      this.logger.error('Session callback threw', e);
-    }
-  }
-
-  _hasSessionModel() {
-    return !!SessionModel;
-  }
-
-  _canUseRedis() {
-    return this.redisEnabled && Date.now() > this.redisRetryAt;
-  }
-
-  _markRedisFailure(err) {
-    this.redisEnabled = false;
-    this.redisRetryAt = Date.now() + this.redisCooldown;
-    this.logger.warn('Redis disabled temporarily', err);
-  }
-
-  /* -------------------- Serialization -------------------- */
-  _serialize(data) {
-    try {
-      const json = JSON.stringify(data);
-      return this.compress
-        ? zlib.deflateSync(Buffer.from(json)).toString('base64')
-        : json;
-    } catch (err) {
-      this.logger.warn('Serialize failed, skipping persistence', err);
-      return null;
-    }
-  }
-
-  _deserialize(raw) {
-    if (!raw) return null;
+  /* ---------- Get ---------- */
 
+  async get(sid, cb) {
     try {
-      const str = this.compress
-        ? zlib.inflateSync(Buffer.from(raw, 'base64')).toString()
-        : raw;
+      const now = Date.now();
 
-      return JSON.parse(str);
-    } catch (err) {
-      this.logger.warn('Deserialize failed, dropping session', err);
-      return null;
-    }
-  }
-
-  /* -------------------- Redis Health -------------------- */
-  async _checkRedisHealth() {
-    try {
-      await this.redis.ping();
-      this.redisEnabled = true;
-      this.logger.info('Redis session store active');
-
-      this.redis.on('error', (err) => this._markRedisFailure(err));
-      this.redis.on('connect', () => {
-        this.redisEnabled = true;
-        this.logger.info('Redis reconnected');
-      });
-    } catch (err) {
-      this.redisEnabled = false;
-      this.logger.warn('Redis unavailable', err);
-    }
-  }
+      const row = await Session
+        .query()
+        .where('sid', sid)
+        .where('expires', '>', now)
+        .first();
 
-  /* -------------------- GET -------------------- */
-  async get(sid, cb) {
-    let sessionData = null;
+      if (!row) return cb(null, null);
 
-    try {
-      if (this.cache.has(sid)) {
-        return this._safeCb(cb, null, this.cache.get(sid));
-      }
+      let sessionJSON;
 
-      if (this._canUseRedis()) {
-        try {
-          const raw = await this.redis.get(`sess:${sid}`);
-          sessionData = this._deserialize(raw);
-        } catch (err) {
-          this._markRedisFailure(err);
-        }
+      // ---------- Step 1: Decompress ----------
+      try {
+        const buffer = Buffer.from(row.data, 'base64');
+        const decompressed = await gunzip(buffer);
+        sessionJSON = decompressed.toString('utf8');
+      } catch {
+        // fallback to legacy plain JSON
+        sessionJSON = row.data;
       }
 
-      if (!sessionData && this._hasSessionModel()) {
-        try {
-          const row = await SessionModel.query()
-            .where('sid', sid)
-            .where('expires', '>', Date.now())
-            .first();
+      // ---------- Step 2: Parse JSON safely ----------
+      try {
+        const parsed = JSON.parse(sessionJSON);
+        return cb(null, parsed);
+      } catch (parseErr) {
+        console.warn('Corrupted session detected. Destroying:', sid);
+
+        // destroy corrupted session
+        await Session
+          .query()
+          .where('sid', sid)
+          .delete();
 
-          if (row) sessionData = this._deserialize(row.data);
-        } catch (err) {
-          this.logger.warn('DB GET failed, disabling DB sessions', err);
-          SessionModel = null;
-        }
+        return cb(null, null); // treat as no session
       }
 
-      if (sessionData) this.cache.set(sid, sessionData);
-      this._safeCb(cb, null, sessionData);
     } catch (err) {
-      this.logger.error('GET failed safely', err);
-      this._safeCb(cb, null, null);
+      console.error('Session GET failed:', err);
+
+      // IMPORTANT: never pass fatal error to express-session
+      return cb(null, null);
     }
   }
 
-  /* -------------------- SET -------------------- */
+  /* ---------- Set ---------- */
+
   async set(sid, sessionData, cb) {
     try {
       const expires =
@@ -4121,75 +4122,63 @@ class LamixSessionStore extends session.Store {
           ? new Date(sessionData.cookie.expires).getTime()
           : Date.now() + this.ttl * 1000;
 
-      const data = this._serialize(sessionData);
-      if (!data) return this._safeCb(cb, null);
+      const json = JSON.stringify(sessionData);
 
-      this.cache.set(sid, sessionData);
+      // Async compression (non-blocking)
+      const compressed = await gzip(json);
+      const base64Data = compressed.toString('base64');
 
-      if (this._hasSessionModel()) {
-        try {
-          const existing = await SessionModel.query()
-            .where('sid', sid)
-            .first();
-
-          if (existing) {
-            await existing.update({ data, expires });
-          } else {
-            await new SessionModel({ sid, data, expires }, false).saveNew();
-          }
-        } catch (err) {
-          this.logger.warn('DB SET failed, disabling DB sessions', err);
-          SessionModel = null;
-        }
-      }
+      const payload = {
+        sid,
+        data: base64Data,
+        expires
+      };
 
-      if (this._canUseRedis()) {
-        try {
-          await this.redis.set(`sess:${sid}`, data, 'PX', expires - Date.now());
-        } catch (err) {
-          this._markRedisFailure(err);
-        }
+      const existing = await Session
+        .query()
+        .where('sid', sid)
+        .first();
+
+      if (existing) {
+        await existing.update(payload);
+      } else {
+        const session = new Session(payload, false);
+        await session.saveNew(payload);
       }
 
-      this._safeCb(cb, null);
+      cb(null);
     } catch (err) {
-      this.logger.error('SET failed safely', err);
-      this._safeCb(cb, null);
+      cb(new DBError('Failed to persist session', {
+        sid,
+        operation: 'set',
+        err
+      }));
     }
   }
 
-  /* -------------------- DESTROY -------------------- */
+  /* ---------- Destroy ---------- */
+
   async destroy(sid, cb) {
     try {
-      this.cache.delete(sid);
+      await Session
+        .query()
+        .where('sid', sid)
+        .delete();
 
-      if (this._hasSessionModel()) {
-        try {
-          await SessionModel.query().where('sid', sid).delete();
-        } catch (err) {
-          this.logger.warn('DB DESTROY failed, disabling DB sessions', err);
-          SessionModel = null;
-        }
-      }
-
-      if (this._canUseRedis()) {
-        try {
-          await this.redis.del(`sess:${sid}`);
-        } catch (err) {
-          this._markRedisFailure(err);
-        }
-      }
-
-      this._safeCb(cb, null);
+      cb(null);
     } catch (err) {
-      this.logger.error('DESTROY failed safely', err);
-      this._safeCb(cb, null);
+      cb(new DBError('Failed to destroy session', {
+        sid,
+        operation: 'destroy',
+        err
+      }));
     }
   }
 
-  /* -------------------- TOUCH -------------------- */
+  /* ---------- Touch ---------- */
+
   async touch(sid, sessionData, cb) {
-    if (!sessionData) return this._safeCb(cb, null);
+    if (!sessionData) return cb(null);
 
     try {
       const expires =
@@ -4197,45 +4186,37 @@ class LamixSessionStore extends session.Store {
           ? new Date(sessionData.cookie.expires).getTime()
           : Date.now() + this.ttl * 1000;
 
-      this.cache.set(sid, sessionData);
+      await Session
+        .query()
+        .where('sid', sid)
+        .update({ expires });
 
-      if (this._hasSessionModel()) {
-        try {
-          await SessionModel.query().where('sid', sid).update({ expires });
-        } catch (err) {
-          this.logger.warn('DB TOUCH failed, disabling DB sessions', err);
-          SessionModel = null;
-        }
-      }
-
-      if (this._canUseRedis()) {
-        try {
-          await this.redis.pexpire(`sess:${sid}`, expires - Date.now());
-        } catch (err) {
-          this._markRedisFailure(err);
-        }
-      }
-
-      this._safeCb(cb, null);
+      cb();
     } catch (err) {
-      this.logger.error('TOUCH failed safely', err);
-      this._safeCb(cb, null);
+      cb(new DBError('Failed to touch session', {
+        sid,
+        operation: 'touch',
+        err
+      }));
     }
   }
 
-  /* -------------------- Cleanup -------------------- */
-  _startCleanup() {
-    if (!this._hasSessionModel()) return;
+  /* ---------- Cleanup ---------- */
 
+  _startCleanup() {
     this._cleanupTimer = setInterval(async () => {
       try {
-        await SessionModel.query()
+        await Session
+          .query()
           .where('expires', '<', Date.now())
           .delete();
       } catch (err) {
-        this.logger.warn('Cleanup failed, disabling DB sessions', err);
-        SessionModel = null;
-        clearInterval(this._cleanupTimer);
+        console.error(
+          new DBError('Session cleanup failed', {
+            operation: 'cleanup',
+            err
+          })
+        );
       }
     }, this.cleanupInterval);
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "lamix",
-  "version": "4.2.19",
+  "version": "4.2.21",
   "description": "lamix - ORM for Node-express js",
-  "main": "./lib",
+  "main": "./lib/index.js",
   "type": "commonjs",
   "exports": {
     ".": {
@@ -32,7 +32,6 @@
     "bcrypt": "^6.0.0",
     "express-session": "^1.19.0",
     "lru-cache": "^11.2.5",
-    "ioredis": "^5.9.2",
     "chalk": "^4.1.2",
     "dotenv": "^17.2.4 "
   },