ilana-orm 1.0.14 → 1.0.16

package/orm/Factory.js

@@ -7,14 +7,14 @@ class Factory {
     this.definition = definition;
     this.faker = faker;
     this.states = new Map();
-    this.afterCreating = [];
-    this.afterMaking = [];
-    this.beforeCreating = [];
-    this.beforeMaking = [];
+    this._afterCreatingCallbacks = [];
+    this._afterMakingCallbacks = [];
+    this._beforeCreatingCallbacks = [];
+    this._beforeMakingCallbacks = [];
     this.count = 1;
     this.currentStates = [];
     this.relationships = new Map();
-    this.sequence = 0;
+    this._sequenceCount = 0;
     this.sequences = new Map();
   }
 
@@ -28,22 +28,22 @@ class Factory {
   }
 
   afterCreating(callback) {
-    this.afterCreating.push(callback);
+    this._afterCreatingCallbacks.push(callback);
     return this;
   }
 
   afterMaking(callback) {
-    this.afterMaking.push(callback);
+    this._afterMakingCallbacks.push(callback);
     return this;
   }
 
   beforeCreating(callback) {
-    this.beforeCreating.push(callback);
+    this._beforeCreatingCallbacks.push(callback);
     return this;
   }
 
   beforeMaking(callback) {
-    this.beforeMaking.push(callback);
+    this._beforeMakingCallbacks.push(callback);
     return this;
   }
 
@@ -75,7 +75,7 @@ class Factory {
   }
 
   sequence() {
-    return ++this.sequence;
+    return ++this._sequenceCount;
   }
 
   // Enhanced sequence methods
@@ -92,7 +92,7 @@ class Factory {
       this.sequences?.set(key, 0);
     } else {
       this.sequences?.clear();
-      this.sequence = 0;
+      this._sequenceCount = 0;
     }
     return this;
   }
@@ -138,8 +138,6 @@ class Factory {
     
     if (typeof this.definition === 'function') {
       modelAttributes = this.definition(faker);
-    } else if (this.definition === undefined && typeof this.definition === 'function') {
-      modelAttributes = this.definition();
     } else {
       throw new Error('Factory must have a definition function');
     }
@@ -153,7 +151,7 @@ class Factory {
 
     modelAttributes = { ...modelAttributes, ...attributes };
 
-    for (const callback of this.beforeMaking) {
+    for (const callback of this._beforeMakingCallbacks) {
       modelAttributes = callback(modelAttributes) || modelAttributes;
     }
 
@@ -167,7 +165,7 @@ class Factory {
     model.fill(modelAttributes);
 
     // Run afterMaking callbacks
-    for (const callback of this.afterMaking) {
+    for (const callback of this._afterMakingCallbacks) {
       await callback(model);
     }
 
@@ -178,14 +176,14 @@ class Factory {
     const model = await this.makeOne(attributes);
     
     // Run beforeCreating callbacks
-    for (const callback of this.beforeCreating) {
+    for (const callback of this._beforeCreatingCallbacks) {
       await callback(model);
     }
-    
+
     await model.save();
 
     // Run afterCreating callbacks
-    for (const callback of this.afterCreating) {
+    for (const callback of this._afterCreatingCallbacks) {
       await callback(model);
     }
 
@@ -243,6 +241,8 @@ class Factory {
       const batchFactory = new Factory(this.model, this.definition);
       batchFactory.count = currentBatchSize;
       batchFactory.currentStates = [...this.currentStates];
+      batchFactory._afterCreatingCallbacks = [...this._afterCreatingCallbacks];
+      batchFactory._beforeCreatingCallbacks = [...this._beforeCreatingCallbacks];
       
       const batch = await batchFactory.create(attributes);
       results.push(...(Array.isArray(batch) ? batch : [batch]));
@@ -352,6 +352,8 @@ if (typeof Model !== 'undefined') {
       // Return a new instance to avoid state pollution
       const newFactory = new Factory(this, existingFactory.definition);
       newFactory.states = new Map(existingFactory.states);
+      newFactory._afterCreatingCallbacks = [...existingFactory._afterCreatingCallbacks];
+      newFactory._beforeCreatingCallbacks = [...existingFactory._beforeCreatingCallbacks];
       return newFactory;
     }
     throw new Error(`No factory defined for model: ${this.name}`);

package/orm/Model.d.ts

@@ -1,12 +1,17 @@
 import QueryBuilder from './QueryBuilder';
-import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } from './Relation';
+import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphOne, MorphMany } from './Relation';
 
 export interface ModelAttributes {
   [key: string]: any;
 }
 
+export interface CastInstance {
+  get(value: any): any;
+  set(value: any): any;
+}
+
 export interface ModelCasts {
-  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float';
+  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float' | CastInstance;
 }
 
 export interface ModelEvents {
@@ -26,7 +31,7 @@ export interface Observer {
   restored?(model: any): Promise<void> | void;
 }
 
-export default class Model {
+export default class Model<TAttributes extends ModelAttributes = ModelAttributes> {
   // Static properties
   protected static table: string;
   protected static connection?: string;
@@ -34,7 +39,10 @@ export default class Model {
   protected static keyType: 'number' | 'string';
   protected static incrementing: boolean;
   protected static timestamps: boolean;
+  protected static createdAt: string;
+  protected static updatedAt: string;
   protected static softDeletes: boolean;
+  protected static deletedAt: string;
   protected static fillable: string[];
   protected static guarded: string[];
   protected static casts: ModelCasts;
@@ -64,6 +72,7 @@ export default class Model {
   static resolveRelatedModel(related: string | typeof Model): typeof Model;
   static query(): QueryBuilder;
   static with(...relations: string[]): QueryBuilder;
+  static withCount(...relations: string[]): QueryBuilder;
   static on(connectionOrTrx: string | any): QueryBuilder;
   static all(): Promise<Model[]>;
   static find(id: any): Promise<Model | null>;
@@ -72,6 +81,10 @@ export default class Model {
   static firstOrFail(): Promise<Model>;
   static latest(column?: string): QueryBuilder;
   static oldest(column?: string): QueryBuilder;
+  static withTrashed(): QueryBuilder;
+  static onlyTrashed(): QueryBuilder;
+  static upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
+  static withoutGlobalScopes(): QueryBuilder;
   static make(attributes?: ModelAttributes): Model;
   static create(attributes?: ModelAttributes): Promise<Model>;
   static generateUuid(): string;
@@ -111,10 +124,19 @@ export default class Model {
   // Instance methods
   getKey(): any;
   fill(attributes: ModelAttributes): this;
+  load(...relations: string[]): Promise<this>;
+  loadMissing(...relations: string[]): Promise<this>;
+  getRelation(key: string): any;
+  relationLoaded(key: string): boolean;
+  makeHidden(keys: string | string[]): this;
+  makeVisible(keys: string | string[]): this;
+  append(keys: string | string[]): this;
   isFillable(key: string): boolean;
   getAttribute(key: string): any;
   setAttribute(key: string, value: any): this;
   syncOriginal(): void;
+  getOriginal(key: string): any;
+  getOriginal(): ModelAttributes;
   save(): Promise<boolean>;
   update(attributes?: ModelAttributes): Promise<boolean>;
   isDirty(key?: string): boolean;
@@ -148,6 +170,7 @@ export default class Model {
     secondLocalKey?: string
   ): HasManyThrough;
   morphTo(typeColumn?: string, idColumn?: string): MorphTo;
+  morphOne(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphOne;
   morphMany(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphMany;
 
   // Protected methods

package/orm/Model.js

@@ -1,6 +1,6 @@
 // Model.js
 const QueryBuilder = require('./QueryBuilder');
-const { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } = require('./Relation');
+const { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany, MorphOne } = require('./Relation');
 const ModelRegistry = require('./ModelRegistry');
 const Database = require('../database/connection');
 
@@ -86,7 +86,8 @@ class Model {
     const allKeys = new Set([
       ...Object.keys(this.attributes || {}),
       ...this.fillable,
-      ...(this._deferred ? Object.keys(this._deferred) : [])
+      ...(this._deferred ? Object.keys(this._deferred) : []),
+      ...(this.appends || [])
     ]);
 
     for (const key of allKeys) {
@@ -105,6 +106,16 @@ class Model {
     }
   }
 
+  _toPascalCase(key) {
+    return key.replace(/(^|_)([a-z])/g, (_, __, c) => c.toUpperCase());
+  }
+
+  _selfFk() {
+    return this.constructor.name
+      .replace(/([A-Z])/g, (m, l, i) => i === 0 ? l.toLowerCase() : '_' + l.toLowerCase())
+      + '_id';
+  }
+
   // --- Static registry & resolving ---
   static register() {
     ModelRegistry.register(this.name, this);
@@ -150,6 +161,7 @@ class Model {
   }
 
   static with(...rels) { return this.query().with(...rels); }
+  static withCount(...rels) { return this.query().withCount(...rels); }
   static on(connectionOrTrx) {
     if (connectionOrTrx && typeof connectionOrTrx.raw === 'function') {
       // It's a transaction object
@@ -166,8 +178,14 @@ class Model {
   static async findBy(column, value) { return this.query().where(column, value).first(); }
   static async first() { return this.query().first(); }
   static async firstOrFail() { return this.query().firstOrFail(); }
-  static latest(col) { return this.query().latest(col || 'created_at'); }
-  static oldest(col) { return this.query().oldest(col || 'created_at'); }
+  static latest(col) { return this.query().latest(col || this.createdAt || 'created_at'); }
+  static oldest(col) { return this.query().oldest(col || this.createdAt || 'created_at'); }
+  static withTrashed() { return this.query().withTrashed(); }
+  static onlyTrashed() { return this.query().onlyTrashed(); }
+  static async upsert(data, uniqueBy, update) { return this.query().upsert(data, uniqueBy, update); }
+  static withoutGlobalScopes() {
+    return new QueryBuilder(this.getTableName(), this, this.getConnectionName());
+  }
 
   static make(attrs = {}) {
     const inst = new this(attrs);
@@ -192,7 +210,16 @@ class Model {
   }
 
   static async insert(data) { return this.query().insert(data); }
-  static async destroy(ids) { return this.query().whereIn(this.primaryKey, Array.isArray(ids) ? ids : [ids]).delete(); }
+  static async destroy(ids) {
+    const idList = Array.isArray(ids) ? ids : [ids];
+    if (this.softDeletes) {
+      const models = await this.query().whereIn(this.primaryKey, idList).get();
+      let count = 0;
+      for (const model of models) { await model.delete(); count++; }
+      return count;
+    }
+    return this.query().whereIn(this.primaryKey, idList).delete();
+  }
   static async firstOrCreate(a, v) { return (await this.query().where(a).first()) || this.create({ ...a, ...v }); }
   static async firstOrNew(a, v) {
     const existing = await this.query().where(a).first();
@@ -211,8 +238,13 @@ class Model {
   }
 
   // scopes
-  static addGlobalScope(n, s) { this.globalScopes.set(n, s); }
-  static removeGlobalScope(n) { this.globalScopes.delete(n); }
+  static addGlobalScope(n, s) {
+    if (!Object.hasOwn(this, 'globalScopes')) this.globalScopes = new Map();
+    this.globalScopes.set(n, s);
+  }
+  static removeGlobalScope(n) {
+    if (Object.hasOwn(this, 'globalScopes')) this.globalScopes.delete(n);
+  }
   static withoutGlobalScope(n) {
     const qb = new QueryBuilder(this.getTableName(), this, this.getConnectionName());
     const scopes = new Map(this.globalScopes);
@@ -220,10 +252,17 @@ class Model {
     scopes.forEach(s => s(qb));
     return qb;
   }
-  static applyGlobalScopes(qb) { this.globalScopes.forEach(s => s(qb)); }
+  static applyGlobalScopes(qb) {
+    const scopes = Object.hasOwn(this, 'globalScopes') ? this.globalScopes : new Map();
+    scopes.forEach(s => s(qb));
+  }
 
   // events
-  static _addEventHandler(evt, fn) { this.events[evt] = this.events[evt] || []; this.events[evt].push(fn); }
+  static _addEventHandler(evt, fn) {
+    if (!Object.hasOwn(this, 'events')) this.events = {};
+    this.events[evt] = this.events[evt] || [];
+    this.events[evt].push(fn);
+  }
   static creating(fn) { this._addEventHandler('creating', fn); }
   static created(fn) { this._addEventHandler('created', fn); }
   static updating(fn) { this._addEventHandler('updating', fn); }
@@ -254,7 +293,8 @@ class Model {
   }
   // static async fireEvent(evt, mdl) { for (const h of this.events[evt] || []) if (await h(mdl) === false) return false; }
   static async fireEvent(evt, mdl) {
-    const handlers = this.events[evt] || [];
+    const ownEvents = Object.hasOwn(this, 'events') ? this.events : {};
+    const handlers = ownEvents[evt] || [];
     for (const handler of handlers) {
       if (await handler(mdl) === false) return false;
     }
@@ -278,6 +318,46 @@ class Model {
     return this;
   }
 
+  async load(...relations) {
+    const qb = new QueryBuilder(this.constructor.getTableName(), this.constructor, this.constructor.getConnectionName());
+    qb.eagerLoad = relations.flat();
+    await qb.loadRelations([this]);
+    return this;
+  }
+
+  async loadMissing(...relations) {
+    const toLoad = relations.flat().filter(r => !(r.split('.')[0] in this.relations));
+    if (toLoad.length) await this.load(...toLoad);
+    return this;
+  }
+
+  getRelation(key) {
+    return this.relations[key];
+  }
+
+  relationLoaded(key) {
+    return Object.prototype.hasOwnProperty.call(this.relations, key);
+  }
+
+  makeHidden(keys) {
+    const list = Array.isArray(keys) ? keys : [keys];
+    this.hidden = [...(this.hidden || []), ...list];
+    return this;
+  }
+
+  makeVisible(keys) {
+    const list = Array.isArray(keys) ? keys : [keys];
+    this.hidden = (this.hidden || []).filter(k => !list.includes(k));
+    return this;
+  }
+
+  append(keys) {
+    const list = Array.isArray(keys) ? keys : [keys];
+    this.appends = [...(this.appends || []), ...list];
+    this._createAttributeGetters();
+    return this;
+  }
+
   isFillable(k) {
     if (Array.isArray(this.fillable) && this.fillable.length) return this.fillable.includes(k);
     if (this.guarded.includes('*')) return false;
@@ -285,36 +365,36 @@ class Model {
   }
 
   getAttribute(k) {
+    const accessor = `get${this._toPascalCase(k)}Attribute`;
+    if (typeof this[accessor] === 'function') {
+      return this[accessor]();
+    }
     const val = this.attributes[k];
     const cast = this.casts[k];
+    if (cast && typeof cast === 'object' && typeof cast.get === 'function') {
+      return cast.get(val);
+    }
     if (cast === 'json' || cast === 'array') {
       try { return JSON.parse(val); } catch { return val; }
     }
-    if (cast === 'date' && val != null) {
-      const config = this._getConfig();
-      const timezone = this.constructor.timezone || config?.timezone || 'UTC';
-
-      try {
-        // Try moment-timezone first
-        const moment = require('moment-timezone');
-        // Parse the stored value as if it's in the configured timezone
-        return moment.tz(val, timezone).format('YYYY-MM-DD HH:mm:ss');
-      } catch (e) {
-        // Fallback: return the stored value as-is since it's already in the correct timezone
-        return val;
-      }
-    }
+    if (cast === 'date' && val != null) return val;
+    if (cast === 'boolean') return val == null ? val : Boolean(val);
+    if (cast === 'number' || cast === 'float') return val == null ? val : Number(val);
     return val;
   }
 
   setAttribute(k, v) {
+    const mutator = `set${this._toPascalCase(k)}Attribute`;
+    if (typeof this[mutator] === 'function') {
+      v = this[mutator](v);
+    }
     const cast = this.casts[k];
     let val = v;
-    if (cast === 'json' || cast === 'array') {
+    if (cast && typeof cast === 'object' && typeof cast.set === 'function') {
+      val = cast.set(v);
+    } else if (cast === 'json' || cast === 'array') {
       val = typeof v === 'string' ? v : JSON.stringify(v);
-    }
-    if (cast === 'date' && v instanceof Date) {
-      // Format date for database storage (YYYY-MM-DD HH:mm:ss)
+    } else if (cast === 'date' && v instanceof Date) {
       const year = v.getFullYear();
       const month = String(v.getMonth() + 1).padStart(2, '0');
       const day = String(v.getDate()).padStart(2, '0');
@@ -324,7 +404,6 @@ class Model {
       val = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
     }
     this.attributes[k] = val;
-    // Only mark as dirty if not during initialization and model exists
     if (!this._deferred && this.exists) {
       this._dirty.add(k);
     }
@@ -336,39 +415,34 @@ class Model {
     this._dirty.clear();
   }
 
+  getOriginal(key) {
+    return key !== undefined ? this.original[key] : { ...this.original };
+  }
+
   _getCurrentTimestamp() {
+    const now = new Date();
     const config = this._getConfig();
     const timezone = this.constructor.timezone || config?.timezone || 'UTC';
-
+    
+    if (timezone === 'UTC') return now;
+    
     try {
-      // Try to use moment-timezone if available
-      const moment = require('moment-timezone');
-      return moment().tz(timezone).toDate();
-    } catch (e) {
-      try {
-        // Try to use date-fns-tz if available
-        const { zonedTimeToUtc } = require('date-fns-tz');
-        return zonedTimeToUtc(new Date(), timezone);
-      } catch (e2) {
-        // Fallback to simple but accurate method
-        const now = new Date();
-        if (timezone === 'UTC') return now;
-
-        // Use toLocaleString for accurate timezone conversion
-        const utcTime = now.getTime() + (now.getTimezoneOffset() * 60000);
-        const targetTime = new Date(utcTime + (this._getTimezoneOffset(timezone, now) * 60000));
-        return targetTime;
-      }
-    }
-  }
-
-  _getTimezoneOffset(timezone, date) {
-    try {
-      const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
-      const targetDate = new Date(date.toLocaleString('en-US', { timeZone: timezone }));
-      return (targetDate.getTime() - utcDate.getTime()) / 60000;
-    } catch (e) {
-      return 0; // Default to UTC
+      const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false
+      });
+      const parts = Object.fromEntries(
+        formatter.formatToParts(now).map(p => [p.type, p.value])
+      );
+      return new Date(`${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}`);
+    } catch {
+      return now;
     }
   }
 
@@ -401,9 +475,12 @@ class Model {
       if (await this.constructor.fireEvent('creating', this) === false) return false;
       if (await this.constructor.fireEvent('saving', this) === false) return false;
 
+      const createdAtCol = this.constructor.createdAt || 'created_at';
+      const updatedAtCol = this.constructor.updatedAt || 'updated_at';
+
       if (this.constructor.timestamps) {
         const now = this._getCurrentTimestamp();
-        this.setAttribute('created_at', now).setAttribute('updated_at', now);
+        this.setAttribute(createdAtCol, now).setAttribute(updatedAtCol, now);
       }
 
       // Generate UUID if needed
@@ -425,16 +502,19 @@ class Model {
       await this.constructor.fireEvent('saved', this);
       this.syncOriginal();
     } else if (this.isDirty()) {
+      const createdAtCol = this.constructor.createdAt || 'created_at';
+      const updatedAtCol = this.constructor.updatedAt || 'updated_at';
+
       // Updating existing record
       if (await this.constructor.fireEvent('updating', this) === false) return false;
       if (await this.constructor.fireEvent('saving', this) === false) return false;
 
       if (this.constructor.timestamps) {
-        this.setAttribute('updated_at', this._getCurrentTimestamp());
+        this.setAttribute(updatedAtCol, this._getCurrentTimestamp());
       }
 
       const updateData = this.getDirty();
-      delete updateData.created_at; // Never update created_at
+      delete updateData[createdAtCol]; // Never update created_at
 
       if (Object.keys(updateData).length > 0) {
         await this.constructor.query().where(this.constructor.primaryKey, this.getKey()).update(updateData);
@@ -470,8 +550,10 @@ class Model {
 
     await this.constructor.fireEvent('deleting', this);
 
+    const deletedAtCol = this.constructor.deletedAt || 'deleted_at';
+
     if (this.constructor.softDeletes) {
-      this.setAttribute('deleted_at', new Date());
+      this.setAttribute(deletedAtCol, new Date());
       await this.save();
     } else {
       await this.constructor.query().where(this.constructor.primaryKey, this.getKey()).delete();
@@ -483,13 +565,14 @@ class Model {
   }
 
   async restore() {
-    if (!this.constructor.softDeletes || !this.getAttribute('deleted_at')) {
+    const deletedAtCol = this.constructor.deletedAt || 'deleted_at';
+    if (!this.constructor.softDeletes || !this.getAttribute(deletedAtCol)) {
       return false;
     }
 
     await this.constructor.fireEvent('restoring', this);
 
-    this.setAttribute('deleted_at', null);
+    this.setAttribute(deletedAtCol, null);
     await this.save();
 
     await this.constructor.fireEvent('restored', this);
@@ -497,7 +580,8 @@ class Model {
   }
 
   trashed() {
-    return this.constructor.softDeletes && this.getAttribute('deleted_at') !== null;
+    const deletedAtCol = this.constructor.deletedAt || 'deleted_at';
+    return this.constructor.softDeletes && this.getAttribute(deletedAtCol) !== null;
   }
 
   only(keys) {
@@ -578,15 +662,18 @@ class Model {
   // relations - convert classes to strings to avoid circular dependencies
   hasOne(related, fk, lk) {
     const relatedName = this._resolveRelatedName(related);
-    return new HasOne(this, relatedName, fk || `${this.constructor.table}_id`, lk || this.constructor.primaryKey);
+    return new HasOne(this, relatedName, fk || this._selfFk(), lk || this.constructor.primaryKey);
   }
   hasMany(related, fk, lk) {
     const relatedName = this._resolveRelatedName(related);
-    return new HasMany(this, relatedName, fk || `${this.constructor.table}_id`, lk || this.constructor.primaryKey);
+    return new HasMany(this, relatedName, fk || this._selfFk(), lk || this.constructor.primaryKey);
   }
   belongsTo(related, fk, ok) {
     const relatedName = this._resolveRelatedName(related);
-    return new BelongsTo(this, relatedName, fk, ok || this.constructor.primaryKey);
+    const defaultFk = typeof relatedName === 'string'
+      ? relatedName.replace(/([A-Z])/g, (m, l, i) => i === 0 ? l.toLowerCase() : '_' + l.toLowerCase()) + '_id'
+      : undefined;
+    return new BelongsTo(this, relatedName, fk || defaultFk, ok || this.constructor.primaryKey);
   }
   belongsToMany(related, pivot, fp, rp, pk, rk) {
     const relatedName = this._resolveRelatedName(related);
@@ -612,6 +699,10 @@ class Model {
     return new HasManyThrough(this, relatedName, throughName, fk, sk, lk, slk);
   }
   morphTo(type, id) { return new MorphTo(this, type, id); }
+  morphOne(related, type, id) {
+    const relatedName = typeof related === 'function' && related.name ? related.name : related;
+    return new MorphOne(this, relatedName, type, id, this.constructor.name);
+  }
   morphMany(related, type, id) {
     const relatedName = typeof related === 'function' && related.name ? related.name : related;
     return new MorphMany(this, relatedName, type, id, this.constructor.name);

package/orm/QueryBuilder.d.ts

@@ -56,27 +56,44 @@ export default class QueryBuilder {
   whereDate(column: string, operator: string, value: string): this;
   whereMonth(column: string, month: number): this;
   whereYear(column: string, year: number): this;
-  whereExists(callback: (query: QueryBuilder) => void): this;
+  whereNotBetween(column: string, range: [any, any]): this;
+  orWhereNull(column: string): this;
+  orWhereNotNull(column: string): this;
+  orWhereIn(column: string, values: any[]): this;
+  orWhereNotIn(column: string, values: any[]): this;
+  orWhereRaw(sql: string, bindings?: any[]): this;
+  whereDay(column: string, operatorOrValue: any, value?: any): this;
+  whereTime(column: string, operatorOrValue: any, value?: any): this;
   when<T>(condition: T, callback: (query: this, condition: T) => void, otherwise?: (query: this) => void): this;
+  unless<T>(condition: T, callback: (query: this) => void, otherwise?: (query: this, condition: T) => void): this;
 
   // Joins
   join(table: string, first: string, operator: string, second: string): this;
   leftJoin(table: string, first: string, operator: string, second: string): this;
   rightJoin(table: string, first: string, operator: string, second: string): this;
+  innerJoin(table: string, first: string, operator: string, second: string): this;
+  crossJoin(table: string): this;
 
   // Ordering and limits
   orderBy(column: string, direction?: 'asc' | 'desc'): this;
+  orderByRaw(sql: string): this;
   latest(column?: string): this;
   oldest(column?: string): this;
+  inRandomOrder(): this;
   limit(count: number): this;
   offset(count: number): this;
   take(count: number): this;
   skip(count: number): this;
+  from(table: string): this;
+  forPage(page: number, perPage?: number): this;
 
   // Grouping
   groupBy(...columns: string[]): this;
   having(column: string, operator: string, value: any): this;
   having(rawSql: string): this;
+  havingRaw(sql: string, bindings?: any[]): this;
+  whereExists(callback: (query: QueryBuilder) => void): this;
+  whereNotExists(callback: (query: QueryBuilder) => void): this;
 
   // Locking
   lockForUpdate(): this;
@@ -85,7 +102,8 @@ export default class QueryBuilder {
   noWait(): this;
 
   // Selection
-  select(...columns: string[]): this;
+  select(...columns: any[]): this;
+  addSelect(...columns: any[]): this;
   distinct(): this;
 
   // Raw queries
@@ -105,14 +123,18 @@ export default class QueryBuilder {
   withConstraints(relations: { [key: string]: (query: QueryBuilder) => void }): this;
   withCount(...relations: string[]): this;
   whereHas(relation: string, callback?: (query: QueryBuilder) => void): this;
+  doesntHave(relation: string): this;
+  whereDoesntHave(relation: string, callback?: (query: QueryBuilder) => void): this;
 
   // Execution methods
   get(): Promise<Collection<Model>>;
   first(): Promise<Model | null>;
+  firstOrFail(): Promise<Model>;
   find(id: any): Promise<Model | null>;
   findOrFail(id: any): Promise<Model>;
   pluck(column: string): Promise<any[]>;
   exists(): Promise<boolean>;
+  doesntExist(): Promise<boolean>;
 
   // Pagination
   paginate(page?: number, perPage?: number): Promise<PaginationResult<Model>>;