lamix 4.2.11 → 4.2.13

package/lib/index.js

@@ -136,30 +136,63 @@ 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();
 
+    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() {
@@ -232,31 +265,51 @@ class DB {
 
       try {
         const result = await executor();
+
         this._emit('query', {
           sql,
           bindings,
           time: performance.now() - start,
           driver: this.driver
         });
+
         return result;
       } catch (err) {
-        this._emit('error', { err, sql, bindings, attempt });
+        const isConnectionError =
+          err?.code === 'PROTOCOL_CONNECTION_LOST' ||
+          err?.code === 'ECONNRESET' ||
+          err?.code === 'ECONNREFUSED' ||
+          err?.code === 'ETIMEDOUT' ||
+          /dead|lost|timeout|reset|closed|connect/i.test(err.message);
+
+        this._emit('error', {
+          err,
+          sql,
+          bindings,
+          attempt,
+          connectionError: isConnectionError
+        });
 
         const canRetry =
-          !isWrite ||
-          this._als.getStore()?.inTransaction;
-
-        if (
-          canRetry &&
-          attempt < this.retryAttempts &&
-          /dead|lost|timeout|reset|closed/i.test(err.message)
-        ) {
+          (!isWrite || this._als.getStore()?.inTransaction) &&
+          isConnectionError;
+
+        if (canRetry && attempt < this.retryAttempts) {
           await this.reconnect();
           await sleep(100 * attempt);
           continue;
         }
 
-        throw new DBError('DB query failed', { sql, bindings, err });
+        throw new DBError(
+          isConnectionError ? 'DB connection failed' : 'DB query failed',
+          {
+            sql,
+            bindings,
+            attempt,
+            connectionError: isConnectionError,
+            err
+          }
+        );
       }
     }
   }
@@ -1146,9 +1199,13 @@ class QueryBuilder {
 
   // Helper to normalize operator
   _normalizeOperator(operator) {
-    const op = operator ? operator.toUpperCase() : '=';
+    const op = operator ? operator.toUpperCase() : '='
     if (!VALID_OPERATORS.includes(op)) {
-      throw new Error(`Invalid SQL operator: ${operator}`);
+      throw new DBError('Invalid SQL operator', {
+        operator,
+        normalized: op,
+        method: '_normalizeOperator'
+      });
     }
 
     // Convert ILIKE to proper operator for MySQL
@@ -1348,7 +1405,13 @@ class QueryBuilder {
   }
 
   whereIn(column, values = []) {
-    if (!Array.isArray(values)) throw new Error('whereIn expects array');
+    if (!Array.isArray(values)) {
+      throw new DBError('whereIn expects an array', {
+        method: 'whereIn',
+        column,
+        values
+      });
+    }
     if (!values.length) {
       return this._pushWhere({ type: 'raw', raw: '0 = 1', bindings: [] });
     }
@@ -1391,7 +1454,13 @@ class QueryBuilder {
   }
 
   whereNotIn(column, values = []) {
-    if (!Array.isArray(values)) throw new Error('whereNotIn expects array');
+    if (!Array.isArray(values)) {
+      throw new DBError('whereNotIn expects an array', {
+        method: 'whereNotIn',
+        column,
+        values
+      });
+    }
     if (!values.length) {
       return this._pushWhere({ type: 'raw', raw: '1 = 1', bindings: [] });
     }
@@ -1576,7 +1645,14 @@ class QueryBuilder {
   whereHas(relationName, callback, boolean = 'AND') {
     const relation = this.modelClass.relations()?.[relationName];
     if (!relation) {
-      throw new Error(`Relation '${relationName}' is not defined on ${this.modelClass.name}`);
+      throw new DBError(
+        `Relation '${relationName}' is not defined`,
+        {
+          model: this.modelClass?.name,
+          relation: relationName,
+          method: 'whereHas'
+        }
+      );
     }
 
     const RelatedModel = relation.model();
@@ -1641,6 +1717,16 @@ class QueryBuilder {
     parts.push('SELECT');
     if (this._distinct) parts.push('DISTINCT');
 
+    // Normalize SELECT * to table.* when a model is attached
+    if (
+      this.modelClass &&
+      this._select.length === 1 &&
+      this._select[0] === '*'
+    ) {
+      const table = this.tableAlias || this.table;
+      this._select = [`${escapeId(table)}.*`];
+    }
+
     parts.push(this._select.length ? this._select.join(', ') : '*');
 
     if (this._fromRaw) {
@@ -1785,7 +1871,10 @@ class QueryBuilder {
           break;
 
         default:
-          throw new Error('Unknown where type: ' + w.type);
+          throw new DBError('Unknown where clause type', {
+            type: w.type,
+            where: w
+          });
       }
     });
 
@@ -1823,20 +1912,29 @@ class QueryBuilder {
     const sql = this._compileSelect();
     const binds = this._gatherBindings();
 
-    const rows = await DB.raw(sql, binds);
+    try {
+      const rows = await DB.raw(sql, binds);
+
+      if (this.modelClass) {
+        const models = rows.map(r => new this.modelClass(r, true));
 
-    if (this.modelClass) {
-      const models = rows.map(r => new this.modelClass(r, true));
+        if (this._with.length) {
+          const loaded = await this._eagerLoad(models);
+          return new Collection(loaded);
+        }
 
-      if (this._with.length) {
-        const loaded = await this._eagerLoad(models);
-        return new Collection(loaded);
+        return new Collection(models);
       }
 
-      return new Collection(models);
+      return new Collection(rows);
+    } catch (err) {
+      throw new DBError('Select query failed', {
+        table: this.table,
+        sql,
+        bindings: binds,
+        err
+      });
     }
-
-    return new Collection(rows);
   }
 
   async first() {
@@ -1849,7 +1947,13 @@ class QueryBuilder {
 
   async firstOrFail() {
     const r = await this.first();
-    if (!r) throw new Error('Record not found');
+    if (!r) {
+      throw new DBError('Record not found', {
+        method: 'firstOrFail',
+        table: this.table,
+        model: this.modelClass?.name
+      });
+    }
     return r;
   }
 
@@ -1860,10 +1964,19 @@ class QueryBuilder {
     c.limit(1);
 
     const sql = c._compileSelect();
-    const b = c._gatherBindings();
+    const bindings = c._gatherBindings();
 
-    const rows = await DB.raw(sql, b);
-    return rows.length > 0;
+    try {
+      const rows = await DB.raw(sql, bindings);
+      return rows.length > 0;
+    } catch (err) {
+      throw new DBError('Exists query failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async doesntExist() {
@@ -1878,11 +1991,19 @@ class QueryBuilder {
     c._offset = null;
 
     const sql = c._compileSelect();
-    const b = c._gatherBindings();
-
-    const rows = await DB.raw(sql, b);
+    const bindings = c._gatherBindings();
 
-    return rows[0] ? Number(rows[0].aggregate) : 0;
+    try {
+      const rows = await DB.raw(sql, bindings);
+      return rows[0] ? Number(rows[0].aggregate) : 0;
+    } catch (err) {
+      throw new DBError('Count query failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async _aggregate(expr) {
@@ -1893,11 +2014,20 @@ class QueryBuilder {
     c._offset = null;
 
     const sql = c._compileSelect();
-    const b = c._gatherBindings();
+    const bindings = c._gatherBindings();
 
-    const rows = await DB.raw(sql, b);
-
-    return rows[0] ? Number(rows[0].aggregate) : 0;
+    try {
+      const rows = await DB.raw(sql, bindings);
+      return rows[0] ? Number(rows[0].aggregate) : 0;
+    } catch (err) {
+      throw new DBError('Aggregate query failed', {
+        table: this.table,
+        expression: expr,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   sum(c) { return this._aggregate(`SUM(${escapeId(c)})`); }
@@ -1911,36 +2041,51 @@ class QueryBuilder {
     c._select = [escapeId(col)];
 
     const sql = c._compileSelect();
-    const b = c._gatherBindings();
-
-    const rows = await DB.raw(sql, b);
+    const bindings = c._gatherBindings();
 
-    return rows.map(r => r[col]);
+    try {
+      const rows = await DB.raw(sql, bindings);
+      return rows.map(r => r[col]);
+    } catch (err) {
+      throw new DBError('Pluck query failed', {
+        table: this.table,
+        column: col,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async paginate(page = 1, perPage = 15) {
     page = Math.max(1, Number(page));
     perPage = Math.max(1, Number(perPage));
 
-    // Build a clone to compute total (safe — uses your existing _clone and count)
-    const countClone = this._clone();
-    countClone._select = [`COUNT(*) AS aggregate`];
-    countClone._orders = [];
-    countClone._limit = null;
-    countClone._offset = null;
-
-    const total = await countClone.count('*');
-
-    const offset = (page - 1) * perPage;
-
-    // Use a clone to fetch rows so we don't mutate caller's builder
-    const rows = await this._clone()
-      .limit(perPage)
-      .offset(offset)
-      .get();
-
-    // Return Paginator instance with .toJSON()
-    return new Paginator(rows, total, page, perPage);
+    try {
+      const countClone = this._clone();
+      countClone._select = [`COUNT(*) AS aggregate`];
+      countClone._orders = [];
+      countClone._limit = null;
+      countClone._offset = null;
+
+      const total = await countClone.count('*');
+
+      const offset = (page - 1) * perPage;
+
+      const rows = await this._clone()
+        .limit(perPage)
+        .offset(offset)
+        .get();
+
+      return new Paginator(rows, total, page, perPage);
+    } catch (err) {
+      throw new DBError('Pagination failed', {
+        table: this.table,
+        page,
+        perPage,
+        err
+      });
+    }
   }
 
   /**************************************************************************
@@ -1955,10 +2100,18 @@ class QueryBuilder {
       `) VALUES (${placeholders})`;
 
     const bindings = Object.values(values);
-
-    const result = await DB.raw(sql, bindings);
-
-    return result.affectedRows || 0;
+    try {
+      const result = await DB.raw(sql, bindings);
+
+      return result.affectedRows || 0;
+    } catch (err) {
+      throw new DBError('Insert failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async insertGetId(values) {
@@ -1970,15 +2123,22 @@ class QueryBuilder {
       `) VALUES (${placeholders})`;
 
     const bindings = Object.values(values);
-
-    const result = await DB.raw(sql, bindings);
-
-    return result.insertId ?? null;
+    try {
+      const result = await DB.raw(sql, bindings);
+
+      return result.insertId ?? null;
+    } catch (err) {
+      throw new DBError('Insert (get ID) failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async update(values) {
     if (!Object.keys(values).length) return 0;
-
     const setClause = Object.keys(values)
       .map(k => `${escapeId(k)} = ?`)
       .join(', ');
@@ -1988,10 +2148,18 @@ class QueryBuilder {
       `UPDATE ${escapeId(this.table)} SET ${setClause} ${whereSql}`;
 
     const bindings = [...Object.values(values), ...this._gatherBindings()];
-
-    const result = await DB.raw(sql, bindings);
-
-    return result.affectedRows || 0;
+    try {
+      const result = await DB.raw(sql, bindings);
+
+      return result.affectedRows || 0;
+    } catch (err) {
+      throw new DBError('Update failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async increment(col, by = 1) {
@@ -2000,11 +2168,20 @@ class QueryBuilder {
       `SET ${escapeId(col)} = ${escapeId(col)} + ? ` +
       this._compileWhereOnly();
 
-    const b = [by, ...this._gatherBindings()];
-
-    const res = await DB.raw(sql, b);
+    const bindings = [by, ...this._gatherBindings()];
 
-    return res.affectedRows || 0;
+    try {
+      const res = await DB.raw(sql, bindings);
+      return res.affectedRows || 0;
+    } catch (err) {
+      throw new DBError('Increment failed', {
+        table: this.table,
+        column: col,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async decrement(col, by = 1) {
@@ -2013,9 +2190,20 @@ class QueryBuilder {
       `SET ${escapeId(col)} = ${escapeId(col)} - ? ` +
       this._compileWhereOnly();
 
-    const b = [by, ...this._gatherBindings()];
-    const res = await DB.raw(sql, b);
-    return res.affectedRows || 0;
+    const bindings = [by, ...this._gatherBindings()];
+
+    try {
+      const res = await DB.raw(sql, bindings);
+      return res.affectedRows || 0;
+    } catch (err) {
+      throw new DBError('Decrement failed', {
+        table: this.table,
+        column: col,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async delete() {
@@ -2023,16 +2211,34 @@ class QueryBuilder {
       `DELETE FROM ${escapeId(this.table)} ` +
       this._compileWhereOnly();
 
-    const b = this._gatherBindings();
+    const bindings = this._gatherBindings();
 
-    const res = await DB.raw(sql, b);
-    return res.affectedRows || 0;
+    try {
+      const res = await DB.raw(sql, bindings);
+      return res.affectedRows || 0;
+    } catch (err) {
+      throw new DBError('Delete failed', {
+        table: this.table,
+        sql,
+        bindings,
+        err
+      });
+    }
   }
 
   async truncate() {
     const sql = `TRUNCATE TABLE ${escapeId(this.table)}`;
-    await DB.raw(sql);
-    return true;
+
+    try {
+      await DB.raw(sql);
+      return true;
+    } catch (err) {
+      throw new DBError('Truncate failed', {
+        table: this.table,
+        sql,
+        err
+      });
+    }
   }
 
   _compileWhereOnly() {
@@ -2044,19 +2250,23 @@ class QueryBuilder {
    * EAGER LOAD (unchanged except robust checks)
    **************************************************************************/
   async _eagerLoad(models) {
-    for (const relName of this._with) {
-      const sample = models[0];
-      if (!sample) return models;
+    if (!models.length) return models;
 
-      const relationMethod = sample[relName];
-      if (typeof relationMethod !== 'function') {
-        throw new Error(`Relation "${relName}" is not a method on ${sample.constructor.name}`);
-      }
+    for (const relName of this._with) {
+      const sample = models.find(m => typeof m[relName] === 'function');
+      if (!sample) continue;
 
-      const relation = relationMethod.call(sample);
+      const relation = sample[relName]();
 
       if (!relation || typeof relation.eagerLoad !== 'function') {
-        throw new Error(`Relation "${relName}" does not have a valid eagerLoad method`);
+        throw new DBError(
+          `Relation "${relName}" is not eager-loadable`,
+          {
+            model: sample.constructor.name,
+            relation: relName,
+            method: 'eagerLoad'
+          }
+        );
       }
 
       await relation.eagerLoad(models, relName);
@@ -2802,28 +3012,57 @@ class Model {
     this._relations = {};
     this._exists = !!fresh;
 
-    // Only store keys with defined values
+    // ──────────────────────────────
+    // 1️⃣ hydrate attributes safely
+    // ──────────────────────────────
     for (const [k, v] of Object.entries(attributes)) {
-      if (v !== undefined) this._attributes[k] = v;
+      if (v !== undefined) {
+        this._attributes[k] = v;
+      }
+    }
+
+    // ──────────────────────────────
+    // 2️⃣ ensure timestamps ALWAYS exist
+    // ──────────────────────────────
+    if (this.constructor.timestamps) {
+      if ('created_at' in attributes)
+        this._attributes.created_at = attributes.created_at;
+
+      if ('updated_at' in attributes)
+        this._attributes.updated_at = attributes.updated_at;
+    }
+
+    // ──────────────────────────────
+    // 3️⃣ always keep primary key
+    // ──────────────────────────────
+    const pk = this.constructor.primaryKey;
+    if (pk && pk in attributes) {
+      this._attributes[pk] = attributes[pk];
     }
 
     this._original = { ...this._attributes, ...data };
 
-    // Define getters for attributes
+    // ──────────────────────────────
+    // 4️⃣ define getters/setters FOR ALL ATTRIBUTES
+    // ──────────────────────────────
     for (const k of Object.keys(this._attributes)) {
       if (!(k in this)) {
         Object.defineProperty(this, k, {
-          get: function() {
-            return this._attributes[k];
-          },
-          enumerable: true
+          get: () => this._attributes[k],
+          set: v => { this._attributes[k] = v; },
+          enumerable: true,
+          configurable: true
         });
       }
     }
   }
 
   static async validate(data, id, ignoreId = null) {
-    if (!Validator) throw new Error('Validator not found.');
+    if (!Validator) {
+      throw new DBError('Validator not found', {
+        model: this.name
+      });
+    }
 
     const rules = this.rules || {};
 
@@ -2897,20 +3136,6 @@ class Model {
     }
   }
 
-  // ──────────────────────────────
-  // Query builder accessors
-  // ──────────────────────────────
-  // static query({ withTrashed = false } = {}) {
-  //   // use tableName getter (throws if missing)
-  //   const qb = new QueryBuilder(this.tableName, this);
-  //   if (this.softDeletes && !withTrashed) {
-  //     // avoid mutating shared _wheres reference
-  //     qb._wheres = Array.isArray(qb._wheres) ? qb._wheres.slice() : [];
-  //     qb._wheres.push({ raw: `${DB.escapeId(this.deletedAt)} IS NULL` });
-  //   }
-  //   return qb;
-  // }
-
   static query({ withTrashed = false } = {}) {
     const qb = new QueryBuilder(this.tableName, this);
 
@@ -3000,14 +3225,26 @@ class Model {
   }
 
   static async findManyBy(col, values = []) {
-    if (!Array.isArray(values)) throw new Error('findManyBy expects an array of values');
+    if (!Array.isArray(values)) {
+      throw new DBError('findManyBy expects an array of values', {
+        method: 'findManyBy',
+        column: col
+      });
+    }
     if (!values.length) return [];
     return await this.query().whereIn(col, values).get();
   }
 
   // additional common accessors
   static async findMany(ids = []) {
-    if (!Array.isArray(ids)) ids = [ids];
+    // if (!Array.isArray(ids)) ids = [ids];
+    if (!Array.isArray(ids)) {
+      throw new DBError('findMany expects an array of IDs', {
+        method: 'findMany',
+        model: this.name,
+        ids
+      });
+    }
     if (!ids.length) return [];
     return await this.query().whereIn(this.primaryKey, ids).get();
   }
@@ -3077,7 +3314,10 @@ class Model {
 
     // 3. Block empty payload
     if (!Object.keys(payload).length) {
-      throw new DBError('Attempted to create with empty payload');
+      throw new DBError('Attempted to create with empty payload', {
+        model: this.name,
+        attrs
+      });
     }
 
     // 4. Create + save
@@ -3164,9 +3404,9 @@ class Model {
   // 🛡 SANITIZATION UTIL
   // ──────────────────────────────
   static isBadValue(value) {
-    if (value === null || value === undefined || value === '') return true;
-    if (typeof value === 'string' && !value.trim()) return true;
-    return false;
+    if (value === null || value === undefined) return true;
+    if (typeof value === 'string' && !value.trim()) return true; // empty string
+    return false; // allow 0, false, etc.
   }
 
   sanitize(attrs = {}) {
@@ -3177,7 +3417,7 @@ class Model {
       const val = attrs[key];
 
       if (!this.constructor.isBadValue(val)) {
-        clean[key] = val;
+        clean[key] = val;   // keep 0, false, etc.
       } else if (keepCols.includes(key)) {
         clean[key] = null;
       }
@@ -3191,13 +3431,24 @@ class Model {
   // ──────────────────────────────
   async fill(attrs = {}) {
     const allowed = this.constructor.fillable || Object.keys(attrs);
+    let filled = false;
 
     for (const key of Object.keys(attrs)) {
       const val = attrs[key];
-      if (allowed.includes(key) && !this.constructor.isBadValue(val)) {
-        this._attributes[key] = val;
+      if (allowed.includes(key) && val !== undefined) {
+        this._attributes[key] = val; // 0, false, null preserved
+        filled = true;
       }
     }
+
+    if (!filled && Object.keys(attrs).length > 0) {
+      throw new DBError('No fillable attributes provided', {
+        model: this.constructor.name,
+        attrs,
+        fillable: allowed
+      });
+    }
+
     return this;
   }
 
@@ -3209,17 +3460,23 @@ class Model {
   // INSERT – validation first
   // ──────────────────────────────
   async saveNew(attrs) {
+    if (!this._exists && !Object.keys(this._attributes).length) {
+      throw new DBError('Cannot save empty model', {
+        model: this.constructor.name
+      });
+    }
+
     const payload = this.sanitize(attrs || this._attributes);
 
-    // Validate BEFORE hooks/db
+    // validate BEFORE hooks/db
     await this.constructor.validate(payload);
     await this.trigger('creating');
 
     // timestamps
     if (this.constructor.timestamps) {
       const now = new Date();
-      payload.created_at = payload.created_at || now;
-      payload.updated_at = payload.updated_at || now;
+      if (payload.created_at === undefined) payload.created_at = now;
+      if (payload.updated_at === undefined) payload.updated_at = now;
     }
 
     // soft deletes
@@ -3231,13 +3488,11 @@ class Model {
     }
 
     const qb = this.constructor.query();
-
     const result = await qb.insert(payload);
 
     // handle pk
     const pk = this.constructor.primaryKey;
     const insertId = Array.isArray(result) ? result[0] : result;
-
     if (!(pk in payload) && insertId !== undefined) {
       payload[pk] = insertId;
     }
@@ -3248,12 +3503,16 @@ class Model {
 
     return this;
   }
-
   // ──────────────────────────────
   // UPDATE – only dirty fields
   // ──────────────────────────────
   async save() {
-    if (!this._exists) return this.saveNew(this._attributes);
+    // if (!this._exists) return this.saveNew(this._attributes);
+    if (!this._exists && !Object.keys(this._attributes).length) {
+      throw new DBError('Cannot save empty model', {
+        model: this.constructor.name
+      });
+    }
 
     await this.trigger('updating');
 
@@ -3264,11 +3523,8 @@ class Model {
     for (const key of Object.keys(attrs)) {
       const val = attrs[key];
 
-      if (val !== orig[key] && !this.constructor.isBadValue(val)) {
-        if (this.constructor.softDeletes &&
-            key === this.constructor.deletedAt) {
-          continue;
-        }
+      if (val !== orig[key] && val !== undefined) { // only treat undefined as "no change"
+        if (this.constructor.softDeletes && key === this.constructor.deletedAt) continue;
         dirty[key] = val;
       }
     }
@@ -3285,14 +3541,10 @@ class Model {
 
     // validate BEFORE db write
     const pk = this.constructor.primaryKey;
-    await this.constructor.validate(
-      { ...this._original, ...payload },
-      this._attributes[pk]
-    );
+    await this.constructor.validate({ ...this._original, ...payload }, this._attributes[pk]);
 
     const id = this._attributes[pk];
     const qb = this.constructor.query();
-
     await qb.where(pk, id).update(payload);
 
     this._original = { ...this.sanitize(this._attributes) };
@@ -3326,8 +3578,13 @@ class Model {
       let rel;
       try {
         rel = fn.call(dummy);
-      } catch {
-        continue;
+      } catch (err) {
+        // continue;
+        throw new DBError('Failed to resolve relation', {
+          model: this.name,
+          relation: name,
+          err
+        });
       }
 
       if (!rel) continue;
@@ -3395,8 +3652,13 @@ class Model {
         // RESTRICT — block delete
         // ──────────────────────────────────
         case 'restrict':
-          throw new Error(
-            `Cannot delete ${this.constructor.name}: related ${relName} exists`
+          throw new DBError(
+            `Cannot delete ${this.constructor.name}: related ${relName} exists`,
+            {
+              model: this.constructor.name,
+              relation: relName,
+              behavior: 'restrict'
+            }
           );
 
         // ──────────────────────────────────
@@ -3458,7 +3720,14 @@ class Model {
 
 
   static async destroy(ids) {
-    if (!Array.isArray(ids)) ids = [ids];
+    if (!Array.isArray(ids)) {
+      throw new DBError('destroy expects an array of IDs', {
+        model: this.name,
+        ids
+      });
+    }
+
+    // if (!Array.isArray(ids)) ids = [ids];
     const pk = this.primaryKey;
 
     // --- Load models so cascade works ---
@@ -3618,7 +3887,12 @@ class Model {
 
   async refresh() {
     const pk = this.constructor.primaryKey;
-    if (!this._attributes[pk]) return this;
+    // if (!this._attributes[pk]) return this;
+    if (!this._attributes[pk]) {
+      throw new DBError('Cannot refresh model without primary key', {
+        model: this.constructor.name
+      });
+    }
     const fresh = await this.constructor.find(this._attributes[pk]);
     if (fresh) {
       this._attributes = { ...fresh._attributes };
@@ -3642,6 +3916,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 {
@@ -3730,4 +4156,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};