lamix 4.2.13 → 4.2.15

package/README.md

@@ -288,21 +288,9 @@ class User extends BaseModel {
     return this.hasMany(Post', 'user_id', 'id').onDelete('cascade');
   }
 
-  # Create sessions Table MySQL/Postgres sql
-  CREATE TABLE sessions (
-    sid VARCHAR(255) PRIMARY KEY,
-    data TEXT NOT NULL,
-    expires BIGINT NOT NULL
-  );
-  CREATE INDEX idx_sessions_expires ON sessions (expires);
-
- # Create sessions Table sqlite sql
-  CREATE TABLE sessions (
-    sid TEXT PRIMARY KEY,
-    data TEXT NOT NULL,
-    expires INTEGER NOT NULL
-  );
-  CREATE INDEX idx_sessions_expires ON sessions (expires);
+  # migrate sessions Table(whenever migration is run session is auto generated if missing)
+  npx lamix migrate
+  ➡️ sessions table + index are guaranteed to exist.
 
   # Session setup
   const express = require('express');
@@ -340,4 +328,4 @@ class User extends BaseModel {
   });
 
   app.listen(3000);
-}
+}

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const fs = require('fs');
 const path = require('path');
@@ -274,6 +274,8 @@ async function runMigrations() {
   DB.initFromEnv();
   await DB.connect();
 
+  await ensureSessionsTable();
+
   const applied = await getAppliedMigrations();
   const files = fs.readdirSync(MIGRATIONS_DIR)
     .filter(f => f.endsWith('.js'))
@@ -348,6 +350,63 @@ async function tableExists(tableName) {
   return false;
 }
 
+// ------------------ SESSION hELPER ------------------
+
+async function ensureSessionsTable() {
+  const exists = await tableExists('sessions');
+  if (exists) {
+    log.info('ℹ️ sessions table already exists. Skipping.');
+    return;
+  }
+
+  log.info('⚙️ Creating sessions table...');
+
+  if (DB.driver === 'mysql') {
+    await DB.raw(`
+      CREATE TABLE sessions (
+        sid VARCHAR(255) PRIMARY KEY,
+        data TEXT NOT NULL,
+        expires BIGINT NOT NULL
+      )
+    `);
+
+    await DB.raw(`
+      CREATE INDEX idx_sessions_expires ON sessions (expires)
+    `);
+  }
+
+  if (DB.driver === 'sqlite') {
+    await DB.raw(`
+      CREATE TABLE sessions (
+        sid TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        expires INTEGER NOT NULL
+      )
+    `);
+
+    await DB.raw(`
+      CREATE INDEX idx_sessions_expires ON sessions (expires)
+    `);
+  }
+
+  if (DB.driver === 'pg') {
+    await DB.raw(`
+      CREATE TABLE sessions (
+        sid VARCHAR(255) PRIMARY KEY,
+        data TEXT NOT NULL,
+        expires BIGINT NOT NULL
+      )
+    `);
+
+    await DB.raw(`
+      CREATE INDEX idx_sessions_expires ON sessions (expires)
+    `);
+  }
+
+  log.success('✅ sessions table created successfully.');
+}
+
+
 
 async function rollbackLastMigration() {
   DB.initFromEnv();

package/lib/index.d.ts

@@ -488,6 +488,31 @@ export class DBError extends Error {
     constructor(message: any, meta?: {});
     meta: {};
 }
+export class LamixSessionStore {
+    constructor(options?: {});
+    ttl: any;
+    cleanupInterval: 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<void>;
+    _startCleanup(): void;
+    _cleanupTimer: any;
+}
 export class BaseModel extends Model {
     static passwordField: string;
     static hashRounds: number;
@@ -586,4 +611,5 @@ declare class Relation {
     deleteBehavior: any;
     onDelete(behavior: any): this;
 }
+import LRU = require("lru-cache");
 export {};

package/lib/index.js

@@ -135,31 +135,6 @@ class DB {
   }
 
   /* ---------- Driver ---------- */
-
-  // static _ensureModule() {
-  //   if (!this.driver) this.initFromEnv();
-
-  //   if (this.driver === 'mysql') {
-  //     const m = tryRequire('mysql2/promise');
-  //     if (!m) throw new DBError('Missing mysql2');
-  //     return m;
-  //   }
-
-  //   if (this.driver === 'pg') {
-  //     const m = tryRequire('pg');
-  //     if (!m) throw new DBError('Missing pg');
-  //     return m;
-  //   }
-
-  //   if (this.driver === 'sqlite') {
-  //     const m = tryRequire('sqlite3');
-  //     if (!m) throw new DBError('Missing sqlite3');
-  //     return m;
-  //   }
-
-  //   throw new DBError(`Unsupported driver: ${this.driver}`);
-  // }
-
   static _ensureModule() {
     if (!this.driver) this.initFromEnv();
 
@@ -3916,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';
@@ -3925,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);
+    }
+  }
 
-  async get(sid, cb) {
+  _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 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 =
@@ -3970,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;
+        }
       }
 
-      cb(null);
+      if (this._canUseRedis()) {
+        try {
+          await this.redis.set(`sess:${sid}`, data, 'PX', expires - Date.now());
+        } catch (err) {
+          this._markRedisFailure(err);
+        }
+      }
+
+      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);
+
+      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;
+        }
+      }
 
-      cb(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 =
@@ -4029,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);
+
+      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;
+        }
+      }
 
-      cb();
+      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,8 +1,9 @@
 {
   "name": "lamix",
-  "version": "4.2.13",
+  "version": "4.2.15",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib",
+  "type": "commonjs",
   "exports": {
     ".": {
       "require": "./lib/index.js",
@@ -31,6 +32,9 @@
   "dependencies": {
     "bcrypt": "^6.0.0",
     "express-session": "^1.19.0",
+    "lru-cache": "^7.18.3",
+    "zlib": "^1.0.5",
+    "ioredis": "^5.9.2",
     "chalk": "^4.1.2",
     "dotenv": "^17.2.2"
   },
@@ -39,6 +43,7 @@
     "orm",
     "nodejs",
     "database",
+    "express",
     "sql"
   ],
   "author": {