lamix 4.2.12 → 4.2.14

package/README.md

@@ -87,7 +87,7 @@ npm i lamix
 2. Install dependencies (if any).  
    > This tool uses `mysql2`,`pg`,`sqlite3` driver, so make sure you install your prefered driver:
  DATABASE CONNECTION IN `.env`FILE
- Configure DB via environment variables: `'DB_CONNECTION=mysql',DB_HOST=your db hast`, `DB_USER=your db user`, `DB_PASS=your db password`, `DB_NAME=your db name`, `DB_PORT=your db port`, `DB_CONNECTION_LIMIT=100`.
+ Configure DB via environment variables: `'DB_CONNECTION=mysql',DB_HOST=your db hast`, `DB_USER=your db user`, `DB_PASS=your db password`, `DB_NAME=your db name`, `DB_PORT=your db port`, `DB_CONNECTION_LIMIT=10`.
 
 ## Quick start
 for database connection use any driver of your choice eg
@@ -271,7 +271,7 @@ class User extends BaseModel {
   }
 
   
-  // Many-to-many: User ↔ Role via pivot user_roles (user_id, role_id)
+  # Many-to-many: User ↔ Role via pivot user_roles (user_id, role_id)
   roles() {
     const Role = require('./Role');
     return this.belongsToMany(
@@ -282,9 +282,50 @@ class User extends BaseModel {
     ).onDelete('detach');
   }
 
-  // One-to-many: User -> Post
+  # One-to-many: User -> Post
   posts() {
     const Post = require('./Post');
     return this.hasMany(Post', 'user_id', 'id').onDelete('cascade');
   }
-}
+
+  # 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');
+  const session = require('express-session');
+  const { DB, LamixSessionStore } = require('lamix');
+
+  DB.initFromEnv();
+
+  (async () => {
+    await DB.connect();
+  })();
+
+  const app = express();
+
+  app.use(
+    session({
+      name: 'lamix.sid',
+      secret: process.env.SESSION_SECRET || 'dev-secret',
+      resave: false,
+      saveUninitialized: false,
+      store: new LamixSessionStore({
+        ttl: 60 * 60 * 24, // 1 day
+      }),
+      cookie: {
+        httpOnly: true,
+        secure: false, // true behind HTTPS
+        maxAge: 1000 * 60 * 60 * 24,
+      },
+    })
+  );
+
+  app.get('/', (req, res) => {
+    req.session.views = (req.session.views || 0) + 1;
+    res.json({ views: req.session.views });
+  });
+
+  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,17 @@ export class DBError extends Error {
     constructor(message: any, meta?: {});
     meta: {};
 }
+export class LamixSessionStore {
+    constructor(options?: {});
+    ttl: any;
+    cleanupInterval: any;
+    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<any>;
+    _startCleanup(): void;
+    _cleanupTimer: NodeJS.Timeout;
+}
 export class BaseModel extends Model {
     static passwordField: string;
     static hashRounds: number;

package/lib/index.js

@@ -135,31 +135,39 @@ class DB {
   }
 
   /* ---------- Driver ---------- */
-
   static _ensureModule() {
     if (!this.driver) this.initFromEnv();
 
+    const safeRequire = (name) => {
+      try {
+        return require(name);
+      } catch (err) {
+        if (err.code === 'ERR_REQUIRE_ASYNC_MODULE') {
+          throw new DBError(
+            `${name} is ESM-only or uses top-level await. Use a CommonJS version.`,
+            { module: name, err }
+          );
+        }
+        throw err;
+      }
+    };
+
     if (this.driver === 'mysql') {
-      const m = tryRequire('mysql2/promise');
-      if (!m) throw new DBError('Missing mysql2');
-      return m;
+      return safeRequire('mysql2/promise');
     }
 
     if (this.driver === 'pg') {
-      const m = tryRequire('pg');
-      if (!m) throw new DBError('Missing pg');
-      return m;
+      return safeRequire('pg');
     }
 
     if (this.driver === 'sqlite') {
-      const m = tryRequire('sqlite3');
-      if (!m) throw new DBError('Missing sqlite3');
-      return m;
+      return safeRequire('sqlite3');
     }
 
     throw new DBError(`Unsupported driver: ${this.driver}`);
   }
 
+
   /* ---------- Connection ---------- */
 
   static async connect() {
@@ -3883,6 +3891,158 @@ class Model {
   }
 }
 
+class Session extends Model {
+  static table = 'sessions';
+  static primaryKey = 'sid';
+  static slugKey = null;
+  static timestamps = false;
+
+  static fillable = ['sid', 'data', 'expires'];
+}
+
+const session = require('express-session');
+
+class LamixSessionStore extends session.Store {
+  constructor(options = {}) {
+    super();
+
+    this.ttl = options.ttl || 86400; // seconds
+    this.cleanupInterval = options.cleanupInterval || 60000;
+
+    this._startCleanup();
+  }
+
+  /* ---------- Get ---------- */
+
+  async get(sid, cb) {
+    try {
+      const now = Date.now();
+
+      const row = await Session
+        .query()
+        .where('sid', sid)
+        .where('expires', '>', now)
+        .first();
+
+      if (!row) return cb(null, null);
+
+      cb(null, JSON.parse(row.data));
+    } catch (err) {
+      cb(new DBError('Failed to load session', {
+        sid,
+        operation: 'get',
+        err
+      }));
+    }
+  }
+
+  /* ---------- Set ---------- */
+
+  async set(sid, sessionData, cb) {
+    try {
+      const expires =
+        sessionData.cookie?.expires
+          ? new Date(sessionData.cookie.expires).getTime()
+          : Date.now() + this.ttl * 1000;
+
+      const payload = {
+        sid,
+        data: JSON.stringify(sessionData),
+        expires
+      };
+
+      // const existing = await Session.find(sid);
+      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);
+      }
+
+      cb(null);
+    } catch (err) {
+      cb(new DBError('Failed to persist session', {
+        sid,
+        operation: 'set',
+        err
+      }));
+    }
+  }
+
+  /* ---------- Destroy ---------- */
+
+  async destroy(sid, cb) {
+    try {
+      await Session
+        .query()
+        .where('sid', sid)
+        .delete();
+
+      cb(null);
+    } catch (err) {
+      cb(new DBError('Failed to destroy session', {
+        sid,
+        operation: 'destroy',
+        err
+      }));
+    }
+  }
+
+  /* ---------- Touch ---------- */
+
+  async touch(sid, sessionData, cb) {
+    if (!sessionData) return cb(null);
+
+    try {
+      const expires =
+        sessionData.cookie?.expires
+          ? new Date(sessionData.cookie.expires).getTime()
+          : Date.now() + this.ttl * 1000;
+
+      await Session
+        .query()
+        .where('sid', sid)
+        .update({ expires });
+
+      cb();
+    } catch (err) {
+      cb(new DBError('Failed to touch session', {
+        sid,
+        operation: 'touch',
+        err
+      }));
+    }
+  }
+
+  /* ---------- Cleanup ---------- */
+
+  _startCleanup() {
+    this._cleanupTimer = setInterval(async () => {
+      try {
+        await Session
+          .query()
+          .where('expires', '<', Date.now())
+          .delete();
+      } catch (err) {
+        // cleanup must NEVER fail silently
+        throw new DBError('Session cleanup failed', {
+          operation: 'cleanup',
+          err
+        });
+      }
+    }, this.cleanupInterval);
+
+    this._cleanupTimer.unref();
+  }
+
+}
+
+
 // --- BaseModel with bcrypt hashing ---
 const bcrypt = tryRequire('bcrypt');
 class BaseModel extends Model {
@@ -3971,4 +4131,4 @@ class BaseModel extends Model {
   }
 }
 
-module.exports = { DB, Model, Validator, ValidationError, Collection, QueryBuilder, HasMany, HasOne, BelongsTo, BelongsToMany, DBError, BaseModel};
+module.exports = { DB, Model, Validator, ValidationError, Collection, QueryBuilder, HasMany, HasOne, BelongsTo, BelongsToMany, DBError, LamixSessionStore, BaseModel};

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "lamix",
-  "version": "4.2.12",
+  "version": "4.2.14",
   "description": "lamix - ORM for Node-express js",
   "main": "./lib",
+  "type": "commonjs",
   "exports": {
     ".": {
       "require": "./lib/index.js",
@@ -30,6 +31,7 @@
   },
   "dependencies": {
     "bcrypt": "^6.0.0",
+    "express-session": "^1.19.0",
     "chalk": "^4.1.2",
     "dotenv": "^17.2.2"
   },
@@ -38,6 +40,7 @@
     "orm",
     "nodejs",
     "database",
+    "express",
     "sql"
   ],
   "author": {
@@ -46,6 +49,6 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">= 0.8.0"
+    "node": ">=18.0.0"
   }
 }