lamix 4.2.20 → 4.2.22

package/lib/{index.d.ts → @types/index.d.ts}

@@ -501,26 +501,12 @@ export class LamixSessionStore {
     constructor(options?: {});
     ttl: any;
     cleanupInterval: any;
-    logger: any;
-    compress: any;
-    cache: LRUCache<{}, {}, unknown>;
-    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;

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');
 
@@ -4043,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;
-    }
-  }
+      const row = await Session
+        .query()
+        .where('sid', sid)
+        .where('expires', '>', now)
+        .first();
 
-  /* -------------------- 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);
-    }
-  }
+      if (!row) return cb(null, null);
 
-  /* -------------------- GET -------------------- */
-  async get(sid, cb) {
-    let sessionData = null;
+      let sessionJSON;
 
-    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);
-        }
+      // ---------- 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 =
@@ -4199,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);
-
-      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);
-        }
-      }
+      await Session
+        .query()
+        .where('sid', sid)
+        .delete();
 
-      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 =
@@ -4275,45 +4186,37 @@ class LamixSessionStore extends session.Store {
           ? new Date(sessionData.cookie.expires).getTime()
           : Date.now() + this.ttl * 1000;
 
-      this.cache.set(sid, sessionData);
-
-      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;
-        }
-      }
+      await Session
+        .query()
+        .where('sid', sid)
+        .update({ expires });
 
-      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,13 +1,14 @@
 {
   "name": "lamix",
-  "version": "4.2.20",
+  "version": "4.2.22",
   "description": "lamix - ORM for Node-express js",
-  "main": "./lib",
+  "main": "./lib/index.js",
+  "types": "./lib/@types/index.d.ts",
   "type": "commonjs",
   "exports": {
     ".": {
       "require": "./lib/index.js",
-      "types": "./lib/index.d.ts"
+      "types": "./lib/@types/index.d.ts"
     }
   },
   "files": [
@@ -32,7 +33,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 "
   },