lamix 4.2.18 → 4.2.20

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;
@@ -494,7 +503,7 @@ export class LamixSessionStore {
     cleanupInterval: any;
     logger: any;
     compress: any;
-    cache: any;
+    cache: LRUCache<{}, {}, unknown>;
     redisEnabled: boolean;
     redisRetryAt: number;
     redisCooldown: any;
@@ -548,23 +557,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 +647,5 @@ declare class Relation {
     deleteBehavior: any;
     onDelete(behavior: any): this;
 }
+import { LRUCache } from "lru-cache";
 export {};

package/lib/index.js

@@ -6,7 +6,7 @@ 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');
 
 /* ---------------- Utilities ---------------- */
@@ -32,68 +32,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 +131,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 +936,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 +3286,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lamix",
-  "version": "4.2.18",
+  "version": "4.2.20",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib",
   "type": "commonjs",