ilana-orm 1.0.17 → 1.0.19

package/orm/QueryBuilder.js

@@ -1,6 +1,7 @@
 const Database = require('../database/connection');
 const Collection = require('./Collection');
 const ModelRegistry = require('./ModelRegistry');
+const { ModelNotFoundException } = require('./Errors');
 
 class QueryBuilder {
   constructor(tableName, modelClass, connectionName) {
@@ -226,7 +227,32 @@ class QueryBuilder {
   }
 
   addSelect(...columns) {
-    this.query.column(...columns);
+    for (const col of columns) {
+      if (col && typeof col === 'object' && !Array.isArray(col)) {
+        // Subquery form: addSelect({ alias: (qb) => qb.from('table').select('col').where(...) })
+        for (const [alias, subFn] of Object.entries(col)) {
+          const knex = Database.connection(this.connectionName);
+          const subQuery = knex.queryBuilder();
+          const subQb = new QueryBuilder('', null, this.connectionName);
+          subQb.query = subQuery;
+          subFn(subQb);
+          this.query.column(knex.raw(`(${subQuery.toSQL().sql}) as "${alias}"`, subQuery.toSQL().bindings));
+        }
+      } else {
+        this.query.column(col);
+      }
+    }
+    return this;
+  }
+
+  orderBySubquery(callback, direction = 'asc') {
+    const knex = Database.connection(this.connectionName);
+    const subQuery = knex.queryBuilder();
+    const subQb = new QueryBuilder('', null, this.connectionName);
+    subQb.query = subQuery;
+    callback(subQb);
+    const { sql, bindings } = subQuery.toSQL();
+    this.query.orderByRaw(`(${sql}) ${direction === 'desc' ? 'desc' : 'asc'}`, bindings);
     return this;
   }
 
@@ -249,6 +275,23 @@ class QueryBuilder {
     return this;
   }
 
+  withPendingAttributes(attrs) {
+    this._pendingAttributes = { ...(this._pendingAttributes || {}), ...attrs };
+    return this;
+  }
+
+  async new(attrs = {}) {
+    const merged = { ...(this._pendingAttributes || {}), ...attrs };
+    const inst = new this.modelClass(merged);
+    inst._initialize();
+    return inst;
+  }
+
+  async create(attrs = {}) {
+    const merged = { ...(this._pendingAttributes || {}), ...attrs };
+    return this.modelClass.create(merged);
+  }
+
   when(condition, callback, otherwise) {
     if (condition) {
       callback(this, condition);
@@ -548,6 +591,37 @@ class QueryBuilder {
     return this.whereDoesntHave(relation);
   }
 
+  has(relation, operator = '>=', count = 1) {
+    if (!this.modelClass) return this;
+    try {
+      const dummy = this._makeDummy();
+      const relFn = this.modelClass.prototype[relation];
+      if (typeof relFn !== 'function') return this;
+      const rel = relFn.call(dummy);
+      const relatedClass = rel.getRelatedClass();
+      const relatedTable = relatedClass.getTableName();
+      const parentTable = this.modelClass.getTableName();
+      const isBelongsTo = rel.constructor.name === 'BelongsTo';
+      const joinCol = isBelongsTo
+        ? `${relatedTable}.${rel.localKey || relatedClass.getPrimaryKey()} = ${parentTable}.${rel.foreignKey}`
+        : `${relatedTable}.${rel.foreignKey} = ${parentTable}.${rel.localKey || this.modelClass.getPrimaryKey()}`;
+      const ops = ['=', '!=', '<', '<=', '>', '>='];
+      const safeOp = ops.includes(operator) ? operator : '>=';
+      const safeCount = parseInt(count, 10) || 1;
+      if (safeOp === '>=' && safeCount === 1) {
+        this.query.whereExists((builder) => {
+          builder.from(relatedTable).whereRaw(joinCol);
+        });
+      } else {
+        this.query.whereRaw(
+          `(select count(*) from ?? where ${joinCol}) ${safeOp} ?`,
+          [relatedTable, safeCount]
+        );
+      }
+    } catch (_) {}
+    return this;
+  }
+
   _makeDummy() {
     const dummy = Object.create(this.modelClass.prototype);
     dummy.attributes = {};
@@ -609,13 +683,13 @@ class QueryBuilder {
 
   async findOrFail(id) {
     const result = await this.find(id);
-    if (!result) throw new Error(`Model not found with id: ${id}`);
+    if (!result) throw new ModelNotFoundException(this.modelClass?.name || 'Model', id);
     return result;
   }
 
   async firstOrFail() {
     const result = await this.first();
-    if (!result) throw new Error('No records found.');
+    if (!result) throw new ModelNotFoundException(this.modelClass?.name || 'Model');
     return result;
   }
 
@@ -623,6 +697,18 @@ class QueryBuilder {
     return !(await this.exists());
   }
 
+  async sole() {
+    const results = await this._softQuery().limit(2);
+    if (results.length === 0) throw new ModelNotFoundException(this.modelClass?.name || 'Model');
+    if (results.length > 1) throw new Error(`${this.modelClass?.name || 'Model'}: sole() found more than one result.`);
+    return this.modelClass ? new this.modelClass(results[0]) : results[0];
+  }
+
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+
   async pluck(column) {
     return await this._softQuery().pluck(column);
   }
@@ -758,6 +844,14 @@ class QueryBuilder {
     return this.query.update(data);
   }
 
+  async increment(column, amount = 1) {
+    return this.query.increment(column, amount);
+  }
+
+  async decrement(column, amount = 1) {
+    return this.query.decrement(column, amount);
+  }
+
   async delete() {
     return this.query.del();
   }
@@ -1033,6 +1127,18 @@ class QueryBuilder {
     return this;
   }
 
+  async restore() {
+    if (!this.modelClass || !this.modelClass.softDeletes) {
+      throw new Error(`restore() requires softDeletes to be enabled on ${this.modelClass?.name || 'the model'}`);
+    }
+    const col = this.modelClass.deletedAt || 'deleted_at';
+    return this._softQuery().update({ [col]: null });
+  }
+
+  async values() {
+    return this._softQuery();
+  }
+
   // Debug
   toSql() {
     return this.query.toSQL().sql;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilana-orm",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,6 +10,11 @@
       "require": "./index.js",
       "types": "./index.d.ts"
     },
+    "./edge": {
+      "import": "./index.edge.mjs",
+      "require": "./index.edge.js",
+      "types": "./index.d.ts"
+    },
     "./orm/Model": {
       "import": "./orm/Model.mjs",
       "require": "./orm/Model.js",