lamix 4.2.14 → 4.2.16

package/lib/index.d.ts

@@ -492,12 +492,26 @@ export class LamixSessionStore {
     constructor(options?: {});
     ttl: any;
     cleanupInterval: any;
-    get(sid: any, cb: any): Promise<any>;
+    logger: any;
+    compress: any;
+    cache: LRU<any, 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>;
     set(sid: any, sessionData: any, cb: any): Promise<void>;
     destroy(sid: any, cb: any): Promise<void>;
-    touch(sid: any, sessionData: any, cb: any): Promise<any>;
+    touch(sid: any, sessionData: any, cb: any): Promise<void>;
     _startCleanup(): void;
-    _cleanupTimer: NodeJS.Timeout;
+    _cleanupTimer: any;
 }
 export class BaseModel extends Model {
     static passwordField: string;
@@ -597,4 +611,5 @@ declare class Relation {
     deleteBehavior: any;
     onDelete(behavior: any): this;
 }
+import LRU = require("lru-cache");
 export {};

package/lib/index.js

@@ -3891,6 +3891,12 @@ class Model {
   }
 }
 
+const session = require('express-session');
+const Redis = require('ioredis');
+const LRU = require('lru-cache');
+const zlib = require('zlib');
+
+/* -------------------- DB Model -------------------- */
 class Session extends Model {
   static table = 'sessions';
   static primaryKey = 'sid';
@@ -3900,44 +3906,159 @@ class Session extends Model {
   static fillable = ['sid', 'data', 'expires'];
 }
 
-const session = require('express-session');
+/* -------------------- Optional Session Model -------------------- */
+let SessionModel = null;
 
+try {
+  // If this throws, DB-backed sessions are simply disabled
+  SessionModel = Session;
+} catch (err) {
+  SessionModel = null;
+}
+
+/* -------------------- Store -------------------- */
 class LamixSessionStore extends session.Store {
   constructor(options = {}) {
     super();
 
-    this.ttl = options.ttl || 86400; // seconds
+    this.ttl = options.ttl || 86400;
     this.cleanupInterval = options.cleanupInterval || 60000;
+    this.logger = options.logger || console;
+    this.compress = options.compress ?? true;
+
+    /* -------- In-memory cache -------- */
+    this.cache = new LRU({
+      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();
   }
 
-  /* ---------- Get ---------- */
+  /* -------------------- Safety Helpers -------------------- */
+  _safeCb(cb, err, result = null) {
+    try {
+      cb(err, result);
+    } catch (e) {
+      this.logger.error('Session callback threw', e);
+    }
+  }
+
+  _hasSessionModel() {
+    return !!SessionModel;
+  }
 
-  async get(sid, cb) {
+  _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 now = Date.now();
+      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;
+    }
+  }
 
-      const row = await Session
-        .query()
-        .where('sid', sid)
-        .where('expires', '>', now)
-        .first();
+  _deserialize(raw) {
+    if (!raw) return null;
 
-      if (!row) return cb(null, null);
+    try {
+      const str = this.compress
+        ? zlib.inflateSync(Buffer.from(raw, 'base64')).toString()
+        : raw;
 
-      cb(null, JSON.parse(row.data));
+      return JSON.parse(str);
     } catch (err) {
-      cb(new DBError('Failed to load session', {
-        sid,
-        operation: 'get',
-        err
-      }));
+      this.logger.warn('Deserialize failed, dropping session', err);
+      return null;
     }
   }
 
-  /* ---------- Set ---------- */
+  /* -------------------- 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);
+    }
+  }
+
+  /* -------------------- GET -------------------- */
+  async get(sid, cb) {
+    let sessionData = null;
+
+    try {
+      if (this.cache.has(sid)) {
+        return this._safeCb(cb, null, this.cache.get(sid));
+      }
+
+      if (this._canUseRedis()) {
+        try {
+          const raw = await this.redis.get(`sess:${sid}`);
+          sessionData = this._deserialize(raw);
+        } catch (err) {
+          this._markRedisFailure(err);
+        }
+      }
+
+      if (!sessionData && this._hasSessionModel()) {
+        try {
+          const row = await SessionModel.query()
+            .where('sid', sid)
+            .where('expires', '>', Date.now())
+            .first();
+
+          if (row) sessionData = this._deserialize(row.data);
+        } catch (err) {
+          this.logger.warn('DB GET failed, disabling DB sessions', err);
+          SessionModel = null;
+        }
+      }
+
+      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);
+    }
+  }
 
+  /* -------------------- SET -------------------- */
   async set(sid, sessionData, cb) {
     try {
       const expires =
@@ -3945,58 +4066,75 @@ class LamixSessionStore extends session.Store {
           ? new Date(sessionData.cookie.expires).getTime()
           : Date.now() + this.ttl * 1000;
 
-      const payload = {
-        sid,
-        data: JSON.stringify(sessionData),
-        expires
-      };
+      const data = this._serialize(sessionData);
+      if (!data) return this._safeCb(cb, null);
 
-      // const existing = await Session.find(sid);
-      const existing = await Session
-      .query()
-      .where('sid', sid)
-      .first();
+      this.cache.set(sid, sessionData);
 
-      if (existing) {
-        await existing.update(payload);
-      } else {
-        const session = new Session(payload, false);
-        await session.saveNew(payload);
+      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;
+        }
+      }
+
+      if (this._canUseRedis()) {
+        try {
+          await this.redis.set(`sess:${sid}`, data, 'PX', expires - Date.now());
+        } catch (err) {
+          this._markRedisFailure(err);
+        }
       }
 
-      cb(null);
+      this._safeCb(cb, null);
     } catch (err) {
-      cb(new DBError('Failed to persist session', {
-        sid,
-        operation: 'set',
-        err
-      }));
+      this.logger.error('SET failed safely', err);
+      this._safeCb(cb, null);
     }
   }
 
-  /* ---------- Destroy ---------- */
-
+  /* -------------------- DESTROY -------------------- */
   async destroy(sid, cb) {
     try {
-      await Session
-        .query()
-        .where('sid', sid)
-        .delete();
+      this.cache.delete(sid);
 
-      cb(null);
+      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);
     } catch (err) {
-      cb(new DBError('Failed to destroy session', {
-        sid,
-        operation: 'destroy',
-        err
-      }));
+      this.logger.error('DESTROY failed safely', err);
+      this._safeCb(cb, null);
     }
   }
 
-  /* ---------- Touch ---------- */
-
+  /* -------------------- TOUCH -------------------- */
   async touch(sid, sessionData, cb) {
-    if (!sessionData) return cb(null);
+    if (!sessionData) return this._safeCb(cb, null);
 
     try {
       const expires =
@@ -4004,45 +4142,54 @@ class LamixSessionStore extends session.Store {
           ? new Date(sessionData.cookie.expires).getTime()
           : Date.now() + this.ttl * 1000;
 
-      await Session
-        .query()
-        .where('sid', sid)
-        .update({ expires });
+      this.cache.set(sid, sessionData);
 
-      cb();
+      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);
     } catch (err) {
-      cb(new DBError('Failed to touch session', {
-        sid,
-        operation: 'touch',
-        err
-      }));
+      this.logger.error('TOUCH failed safely', err);
+      this._safeCb(cb, null);
     }
   }
 
-  /* ---------- Cleanup ---------- */
-
+  /* -------------------- Cleanup -------------------- */
   _startCleanup() {
+    if (!this._hasSessionModel()) return;
+
     this._cleanupTimer = setInterval(async () => {
       try {
-        await Session
-          .query()
+        await SessionModel.query()
           .where('expires', '<', Date.now())
           .delete();
       } catch (err) {
-        // cleanup must NEVER fail silently
-        throw new DBError('Session cleanup failed', {
-          operation: 'cleanup',
-          err
-        });
+        this.logger.warn('Cleanup failed, disabling DB sessions', err);
+        SessionModel = null;
+        clearInterval(this._cleanupTimer);
       }
     }, this.cleanupInterval);
 
     this._cleanupTimer.unref();
   }
-
 }
 
 
+
 // --- BaseModel with bcrypt hashing ---
 const bcrypt = tryRequire('bcrypt');
 class BaseModel extends Model {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lamix",
-  "version": "4.2.14",
+  "version": "4.2.16",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib",
   "type": "commonjs",
@@ -32,6 +32,8 @@
   "dependencies": {
     "bcrypt": "^6.0.0",
     "express-session": "^1.19.0",
+    "lru-cache": "^7.18.3",
+    "ioredis": "^5.9.2",
     "chalk": "^4.1.2",
     "dotenv": "^17.2.2"
   },