@bunnykit/orm 0.1.4 → 0.1.6

package/dist/src/model/Model.d.ts

@@ -97,10 +97,13 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     $exists: boolean;
     $relations: Record<string, any>;
     $casts: Record<string, CastDefinition>;
+    $connection?: Connection;
     constructor(attributes?: Partial<T>);
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
+    static on<M extends typeof Model>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
+    static forTenant<M extends typeof Model>(this: M, tenantId: string): Builder<InstanceType<M>>;
     static query<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
     static addGlobalScope(name: string, scope: GlobalScope): void;
     static removeGlobalScope(name: string): void;
@@ -109,12 +112,39 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static shouldAutoGeneratePrimaryKey(): Promise<boolean>;
     static create<M extends typeof Model>(this: M, attributes: Partial<InstanceType<M> extends Model<infer U> ? U : Record<string, any>>): Promise<InstanceType<M>>;
     static find<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M> | null>;
+    static findOrFail<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M>>;
     static first<M extends typeof Model>(this: M): Promise<InstanceType<M> | null>;
+    static firstOrFail<M extends typeof Model>(this: M): Promise<InstanceType<M>>;
+    static firstOrCreate<M extends typeof Model>(this: M, attributes?: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
+    static updateOrCreate<M extends typeof Model>(this: M, attributes: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
     static where<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orderBy<M extends typeof Model>(this: M, column: string, direction?: "asc" | "desc"): Builder<InstanceType<M>>;
     static whereIn<M extends typeof Model>(this: M, column: string, values: any[]): Builder<InstanceType<M>>;
     static whereNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
     static whereNotNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
     static orWhere<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereNot<M extends typeof Model>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
+    static orWhereNot<M extends typeof Model>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
+    static whereDate<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereDate<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereDay<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereDay<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereMonth<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereMonth<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereYear<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereYear<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereTime<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereTime<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static latest<M extends typeof Model>(this: M, column?: string): Builder<InstanceType<M>>;
+    static oldest<M extends typeof Model>(this: M, column?: string): Builder<InstanceType<M>>;
+    static when<M extends typeof Model>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static unless<M extends typeof Model>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static tap<M extends typeof Model>(this: M, callback: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static take<M extends typeof Model>(this: M, count: number): Builder<InstanceType<M>>;
+    static skip<M extends typeof Model>(this: M, count: number): Builder<InstanceType<M>>;
+    static inRandomOrder<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static lockForUpdate<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static sharedLock<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
     static with<M extends typeof Model>(this: M, ...relations: string[]): Builder<InstanceType<M>>;
     static withTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
     static onlyTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
@@ -131,9 +161,15 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static withMax<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
     static all<M extends typeof Model>(this: M): Promise<InstanceType<M>[]>;
     static paginate<M extends typeof Model>(this: M, perPage?: number, page?: number): Promise<import("../query/Builder.js").Paginator<InstanceType<M>>>;
+    static chunk<M extends typeof Model>(this: M, count: number, callback: (items: InstanceType<M>[]) => void | Promise<void>): Promise<void>;
+    static each<M extends typeof Model>(this: M, count: number, callback: (item: InstanceType<M>) => void | Promise<void>): Promise<void>;
+    static cursor<M extends typeof Model>(this: M): AsyncGenerator<InstanceType<M>>;
+    static lazy<M extends typeof Model>(this: M, count?: number): AsyncGenerator<InstanceType<M>>;
     static eagerLoadRelations(models: Model[], relations: string[]): Promise<void>;
     static eagerLoadRelation(models: Model[], relationName: string): Promise<void>;
     fill(attributes: Partial<T>): this;
+    setConnection(connection: Connection): this;
+    getConnection(): Connection;
     isFillable(key: string): boolean;
     getAttribute<K extends keyof T>(key: K): T[K];
     getAttribute(key: string): any;
@@ -147,6 +183,11 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     getDirty(): Partial<T>;
     isDirty(): boolean;
     save(): Promise<this>;
+    updateTimestamps(): void;
+    touch(): Promise<boolean>;
+    increment(column: string, amount?: number, extra?: Record<string, any>): Promise<this>;
+    decrement(column: string, amount?: number, extra?: Record<string, any>): Promise<this>;
+    load(...relations: string[]): Promise<this>;
     delete(): Promise<boolean>;
     restore(): Promise<boolean>;
     forceDelete(): Promise<boolean>;

package/dist/src/model/Model.js

@@ -4,6 +4,9 @@ import { ObserverRegistry } from "./Observer.js";
 import { MorphTo, MorphOne, MorphMany, MorphToMany } from "./MorphRelations.js";
 import { BelongsToMany } from "./BelongsToMany.js";
 import { Schema } from "../schema/Schema.js";
+import { ModelNotFoundError } from "./ModelNotFoundError.js";
+import { ConnectionManager } from "../connection/ConnectionManager.js";
+import { TenantContext } from "../connection/TenantContext.js";
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -31,7 +34,7 @@ export class Relation {
     constructor(parent, related, foreignKey, localKey) {
         this.parent = parent;
         this.related = related;
-        this.builder = related.query();
+        this.builder = related.on(parent.getConnection());
         this.foreignKey = foreignKey || this.defaultForeignKey();
         this.localKey = localKey || related.primaryKey;
     }
@@ -45,7 +48,7 @@ export class Relation {
         return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
     }
     newExistenceQuery(parentQuery, aggregate, callback) {
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(parentQuery.connection).select(aggregate);
         query.whereColumn(`${this.related.getTable()}.${this.foreignKey}`, "=", `${parentQuery.tableName}.${this.localKey}`);
         if (callback)
             callback(query);
@@ -73,7 +76,7 @@ export class HasMany extends Relation {
         this.builder.where(this.foreignKey, parentValue);
     }
     addEagerConstraints(models) {
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const keys = models.map((m) => m.getAttribute(this.localKey));
         this.builder.whereIn(this.foreignKey, keys);
     }
@@ -120,7 +123,7 @@ export class BelongsTo extends Relation {
         this.builder.where(this.localKey, childValue);
     }
     addEagerConstraints(models) {
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const keys = models.map((m) => m.getAttribute(this.foreignKey));
         this.builder.whereIn(this.localKey, keys);
     }
@@ -151,7 +154,7 @@ export class BelongsTo extends Relation {
         return this.parent;
     }
     newExistenceQuery(parentQuery, aggregate, callback) {
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(parentQuery.connection).select(aggregate);
         query.whereColumn(`${this.related.getTable()}.${this.localKey}`, "=", `${parentQuery.tableName}.${this.foreignKey}`);
         if (callback)
             callback(query);
@@ -183,7 +186,7 @@ export class HasManyThrough extends Relation {
         const throughTable = this.through.getTable();
         const relatedTable = this.related.getTable();
         const keys = models.map((m) => m.getAttribute(this.localKey));
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         this.builder.select(`${relatedTable}.*`, `${throughTable}.${this.firstKey}`);
         this.builder.join(throughTable, `${throughTable}.${this.secondLocalKey}`, "=", `${relatedTable}.${this.secondKey}`);
         this.builder.whereIn(`${throughTable}.${this.firstKey}`, keys);
@@ -211,7 +214,7 @@ export class HasManyThrough extends Relation {
     newExistenceQuery(parentQuery, aggregate, callback) {
         const throughTable = this.through.getTable();
         const relatedTable = this.related.getTable();
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(parentQuery.connection).select(aggregate);
         query.join(throughTable, `${throughTable}.${this.secondLocalKey}`, "=", `${relatedTable}.${this.secondKey}`);
         query.whereColumn(`${throughTable}.${this.firstKey}`, "=", `${parentQuery.tableName}.${this.localKey}`);
         if (callback)
@@ -249,7 +252,7 @@ export class HasOne extends Relation {
         this.builder.where(this.foreignKey, parentValue);
     }
     addEagerConstraints(models) {
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const keys = models.map((m) => m.getAttribute(this.localKey));
         this.builder.whereIn(this.foreignKey, keys);
     }
@@ -292,6 +295,7 @@ export class Model {
     $exists = false;
     $relations = {};
     $casts = {};
+    $connection;
     constructor(attributes) {
         const defaults = this.constructor.attributes;
         if (Object.keys(defaults).length > 0) {
@@ -337,16 +341,35 @@ export class Model {
         return this.table || snakeCase(this.name) + "s";
     }
     static getConnection() {
-        if (!this.connection) {
+        const tenantConnection = TenantContext.current()?.connection;
+        const ownConnection = Object.prototype.hasOwnProperty.call(this, "connection") ? this.connection : undefined;
+        const connection = ownConnection || tenantConnection || this.connection || ConnectionManager.getDefault();
+        if (!connection) {
             throw new Error(`No connection set on model ${this.name}`);
         }
-        return this.connection;
+        return connection;
     }
     static setConnection(connection) {
         this.connection = connection;
+        ConnectionManager.setDefault(connection);
+    }
+    static on(connection) {
+        const resolved = typeof connection === "string" ? ConnectionManager.require(connection) : connection;
+        const builder = new Builder(resolved, resolved.qualifyTable(this.getTable()));
+        builder.setModel(this);
+        this.applyGlobalScopes(builder);
+        return builder;
+    }
+    static forTenant(tenantId) {
+        const context = ConnectionManager.getResolvedTenant(tenantId);
+        if (!context) {
+            throw new Error(`Tenant "${tenantId}" has not been resolved. Use TenantContext.run() or await ConnectionManager.resolveTenant() first.`);
+        }
+        return this.on(context.connection);
     }
     static query() {
-        const builder = new Builder(this.getConnection(), this.getTable());
+        const connection = this.getConnection();
+        const builder = new Builder(connection, connection.qualifyTable(this.getTable()));
         builder.setModel(this);
         this.applyGlobalScopes(builder);
         return builder;
@@ -397,12 +420,44 @@ export class Model {
     static async find(id) {
         return this.query().find(id, this.primaryKey);
     }
+    static async findOrFail(id) {
+        const result = await this.find(id);
+        if (!result) {
+            throw new ModelNotFoundError(this.name, id);
+        }
+        return result;
+    }
     static async first() {
         return this.query().first();
     }
+    static async firstOrFail() {
+        const result = await this.first();
+        if (!result) {
+            throw new ModelNotFoundError(this.name);
+        }
+        return result;
+    }
+    static async firstOrCreate(attributes = {}, values = {}) {
+        const found = await this.where(attributes).first();
+        if (found)
+            return found;
+        return this.create({ ...attributes, ...values });
+    }
+    static async updateOrCreate(attributes, values = {}) {
+        const found = await this.where(attributes).first();
+        if (found) {
+            found.fill(values);
+            await found.save();
+            return found;
+        }
+        return this.create({ ...attributes, ...values });
+    }
     static where(column, operator, value) {
         return this.query().where(column, operator, value);
     }
+    static orderBy(column, direction) {
+        return this.query().orderBy(column, direction);
+    }
     static whereIn(column, values) {
         return this.query().whereIn(column, values);
     }
@@ -415,6 +470,72 @@ export class Model {
     static orWhere(column, operator, value) {
         return this.query().orWhere(column, operator, value);
     }
+    static whereNot(column, value) {
+        return this.query().whereNot(column, value);
+    }
+    static orWhereNot(column, value) {
+        return this.query().orWhereNot(column, value);
+    }
+    static whereDate(column, operator, value) {
+        return this.query().whereDate(column, operator, value);
+    }
+    static orWhereDate(column, operator, value) {
+        return this.query().orWhereDate(column, operator, value);
+    }
+    static whereDay(column, operator, value) {
+        return this.query().whereDay(column, operator, value);
+    }
+    static orWhereDay(column, operator, value) {
+        return this.query().orWhereDay(column, operator, value);
+    }
+    static whereMonth(column, operator, value) {
+        return this.query().whereMonth(column, operator, value);
+    }
+    static orWhereMonth(column, operator, value) {
+        return this.query().orWhereMonth(column, operator, value);
+    }
+    static whereYear(column, operator, value) {
+        return this.query().whereYear(column, operator, value);
+    }
+    static orWhereYear(column, operator, value) {
+        return this.query().orWhereYear(column, operator, value);
+    }
+    static whereTime(column, operator, value) {
+        return this.query().whereTime(column, operator, value);
+    }
+    static orWhereTime(column, operator, value) {
+        return this.query().orWhereTime(column, operator, value);
+    }
+    static latest(column) {
+        return this.query().latest(column);
+    }
+    static oldest(column) {
+        return this.query().oldest(column);
+    }
+    static when(condition, callback, defaultCallback) {
+        return this.query().when(condition, callback, defaultCallback);
+    }
+    static unless(condition, callback, defaultCallback) {
+        return this.query().unless(condition, callback, defaultCallback);
+    }
+    static tap(callback) {
+        return this.query().tap(callback);
+    }
+    static take(count) {
+        return this.query().take(count);
+    }
+    static skip(count) {
+        return this.query().skip(count);
+    }
+    static inRandomOrder() {
+        return this.query().inRandomOrder();
+    }
+    static lockForUpdate() {
+        return this.query().lockForUpdate();
+    }
+    static sharedLock() {
+        return this.query().sharedLock();
+    }
     static with(...relations) {
         return this.query().with(...relations);
     }
@@ -463,6 +584,18 @@ export class Model {
     static async paginate(perPage, page) {
         return this.query().paginate(perPage, page);
     }
+    static async chunk(count, callback) {
+        return this.query().chunk(count, callback);
+    }
+    static async each(count, callback) {
+        return this.query().each(count, callback);
+    }
+    static cursor() {
+        return this.query().cursor();
+    }
+    static lazy(count) {
+        return this.query().lazy(count);
+    }
     static async eagerLoadRelations(models, relations) {
         for (const relationName of relations) {
             if (relationName.includes(".")) {
@@ -502,6 +635,13 @@ export class Model {
         }
         return this;
     }
+    setConnection(connection) {
+        this.$connection = connection;
+        return this;
+    }
+    getConnection() {
+        return this.$connection || this.constructor.getConnection();
+    }
     isFillable(key) {
         const constructor = this.constructor;
         if (constructor.fillable.length > 0) {
@@ -634,7 +774,8 @@ export class Model {
             const dirty = this.getDirty();
             if (Object.keys(dirty).length > 0) {
                 const pk = this.getAttribute(constructor.primaryKey);
-                await new Builder(constructor.getConnection(), constructor.getTable())
+                const connection = this.getConnection();
+                await new Builder(connection, connection.qualifyTable(constructor.getTable()))
                     .where(constructor.primaryKey, pk)
                     .update(dirty);
             }
@@ -657,11 +798,12 @@ export class Model {
                 const generated = crypto.randomUUID();
                 this.$attributes[primaryKey] = generated;
             }
+            const connection = this.getConnection();
             if (shouldGeneratePrimaryKey || primaryKeyValue !== null && primaryKeyValue !== undefined && primaryKeyValue !== "") {
-                await new Builder(constructor.getConnection(), constructor.getTable()).insert(this.$attributes);
+                await new Builder(connection, connection.qualifyTable(constructor.getTable())).insert(this.$attributes);
             }
             else {
-                const result = await new Builder(constructor.getConnection(), constructor.getTable()).insertGetId(this.$attributes);
+                const result = await new Builder(connection, connection.qualifyTable(constructor.getTable())).insertGetId(this.$attributes);
                 if (result) {
                     this.$attributes[constructor.primaryKey] = result;
                 }
@@ -673,6 +815,59 @@ export class Model {
         }
         return this;
     }
+    updateTimestamps() {
+        const constructor = this.constructor;
+        if (!constructor.timestamps)
+            return;
+        const now = this.freshTimestamp();
+        this.$attributes["updated_at"] = now;
+        if (!this.$exists) {
+            this.$attributes["created_at"] = now;
+        }
+    }
+    async touch() {
+        if (!this.$exists)
+            return false;
+        const constructor = this.constructor;
+        if (!constructor.timestamps)
+            return false;
+        const now = this.freshTimestamp();
+        const pk = this.getAttribute(constructor.primaryKey);
+        const connection = this.getConnection();
+        await new Builder(connection, connection.qualifyTable(constructor.getTable()))
+            .where(constructor.primaryKey, pk)
+            .update({ updated_at: now });
+        this.$attributes["updated_at"] = now;
+        this.$original = { ...this.$attributes };
+        return true;
+    }
+    async increment(column, amount = 1, extra = {}) {
+        const constructor = this.constructor;
+        const pk = this.getAttribute(constructor.primaryKey);
+        if (!pk)
+            return this;
+        const connection = this.getConnection();
+        const builder = new Builder(connection, connection.qualifyTable(constructor.getTable()))
+            .where(constructor.primaryKey, pk);
+        if (constructor.timestamps) {
+            extra = { ...extra, updated_at: this.freshTimestamp() };
+        }
+        await builder.increment(column, amount, extra);
+        this.$attributes[column] = (this.$attributes[column] || 0) + amount;
+        for (const [key, value] of Object.entries(extra)) {
+            this.$attributes[key] = value;
+        }
+        this.$original = { ...this.$attributes };
+        return this;
+    }
+    async decrement(column, amount = 1, extra = {}) {
+        return this.increment(column, -amount, extra);
+    }
+    async load(...relations) {
+        const constructor = this.constructor;
+        await constructor.eagerLoadRelations([this], relations);
+        return this;
+    }
     async delete() {
         const constructor = this.constructor;
         await ObserverRegistry.dispatch("deleting", this);
@@ -681,14 +876,16 @@ export class Model {
             return false;
         if (constructor.softDeletes) {
             const deletedAt = this.freshTimestamp();
-            await new Builder(constructor.getConnection(), constructor.getTable())
+            const connection = this.getConnection();
+            await new Builder(connection, connection.qualifyTable(constructor.getTable()))
                 .where(constructor.primaryKey, pk)
                 .update({ [constructor.deletedAtColumn]: deletedAt });
             this.$attributes[constructor.deletedAtColumn] = deletedAt;
             this.$original = { ...this.$attributes };
         }
         else {
-            await new Builder(constructor.getConnection(), constructor.getTable())
+            const connection = this.getConnection();
+            await new Builder(connection, connection.qualifyTable(constructor.getTable()))
                 .where(constructor.primaryKey, pk)
                 .delete();
             this.$exists = false;
@@ -703,7 +900,8 @@ export class Model {
         const pk = this.getAttribute(constructor.primaryKey);
         if (!pk)
             return false;
-        await new Builder(constructor.getConnection(), constructor.getTable())
+        const connection = this.getConnection();
+        await new Builder(connection, connection.qualifyTable(constructor.getTable()))
             .where(constructor.primaryKey, pk)
             .update({ [constructor.deletedAtColumn]: null });
         this.$attributes[constructor.deletedAtColumn] = null;
@@ -716,7 +914,8 @@ export class Model {
         const pk = this.getAttribute(constructor.primaryKey);
         if (!pk)
             return false;
-        await new Builder(constructor.getConnection(), constructor.getTable())
+        const connection = this.getConnection();
+        await new Builder(connection, connection.qualifyTable(constructor.getTable()))
             .where(constructor.primaryKey, pk)
             .delete();
         this.$exists = false;

package/dist/src/model/ModelNotFoundError.d.ts

@@ -0,0 +1,5 @@
+export declare class ModelNotFoundError extends Error {
+    modelName: string;
+    identifiers?: any;
+    constructor(modelName: string, identifiers?: any);
+}

package/dist/src/model/ModelNotFoundError.js

@@ -0,0 +1,13 @@
+export class ModelNotFoundError extends Error {
+    modelName;
+    identifiers;
+    constructor(modelName, identifiers) {
+        const msg = identifiers !== undefined
+            ? `No query results for model [${modelName}] ${JSON.stringify(identifiers)}`
+            : `No query results for model [${modelName}]`;
+        super(msg);
+        this.name = "ModelNotFoundError";
+        this.modelName = modelName;
+        this.identifiers = identifiers;
+    }
+}

package/dist/src/model/MorphRelations.js

@@ -31,7 +31,7 @@ export class MorphTo {
         if (!Related) {
             throw new Error(`No morph mapping found for type: ${type}. Register it with MorphMap.register() or pass a typeMap.`);
         }
-        return Related.find(id);
+        return Related.on(this.parent.getConnection()).find(id);
     }
     addEagerConstraints(models) {
         // MorphTo eager loading is handled separately in getEager
@@ -83,7 +83,7 @@ export class MorphOne {
         this.typeColumn = typeColumn || `${name}_type`;
         this.idColumn = idColumn || `${name}_id`;
         this.localKey = localKey || parent.constructor.primaryKey;
-        this.builder = related.query();
+        this.builder = related.on(parent.getConnection());
         this.builder.where(this.typeColumn, this.getMorphType());
         this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
     }
@@ -94,7 +94,7 @@ export class MorphOne {
         return this.builder;
     }
     addEagerConstraints(models) {
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const keys = models.map((m) => m.getAttribute(this.localKey));
         this.builder.whereIn(this.idColumn, keys);
         this.builder.where(this.typeColumn, this.getMorphType());
@@ -120,7 +120,7 @@ export class MorphOne {
         return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
     }
     newExistenceQuery(parentTable, aggregate, callback) {
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(this.parent.getConnection()).select(aggregate);
         query.whereColumn(`${this.related.getTable()}.${this.idColumn}`, "=", `${parentTable}.${this.localKey}`);
         query.where(`${this.related.getTable()}.${this.typeColumn}`, this.getMorphType());
         if (callback)
@@ -152,7 +152,7 @@ export class MorphMany {
         this.typeColumn = typeColumn || `${name}_type`;
         this.idColumn = idColumn || `${name}_id`;
         this.localKey = localKey || parent.constructor.primaryKey;
-        this.builder = related.query();
+        this.builder = related.on(parent.getConnection());
         this.builder.where(this.typeColumn, this.getMorphType());
         this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
     }
@@ -163,7 +163,7 @@ export class MorphMany {
         return this.builder;
     }
     addEagerConstraints(models) {
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const keys = models.map((m) => m.getAttribute(this.localKey));
         this.builder.whereIn(this.idColumn, keys);
         this.builder.where(this.typeColumn, this.getMorphType());
@@ -191,7 +191,7 @@ export class MorphMany {
         return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
     }
     newExistenceQuery(parentTable, aggregate, callback) {
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(this.parent.getConnection()).select(aggregate);
         query.whereColumn(`${this.related.getTable()}.${this.idColumn}`, "=", `${parentTable}.${this.localKey}`);
         query.where(`${this.related.getTable()}.${this.typeColumn}`, this.getMorphType());
         if (callback)
@@ -229,7 +229,7 @@ export class MorphToMany {
         this.morphType = morphType || parent.constructor.morphName || parent.constructor.name;
         this.foreignPivotKey = foreignPivotKey || `${snakeCase(name)}_id`;
         this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
-        this.builder = related.query();
+        this.builder = related.on(parent.getConnection());
         this.addConstraints();
     }
     addConstraints() {
@@ -245,7 +245,7 @@ export class MorphToMany {
     addEagerConstraints(models) {
         const keys = models.map((m) => m.getAttribute(this.parentKey));
         const relatedTable = this.related.getTable();
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         this.builder.select(`${relatedTable}.*`, `${this.table}.${this.foreignPivotKey}`);
         this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
         this.builder.whereIn(`${this.table}.${this.foreignPivotKey}`, keys);
@@ -276,7 +276,7 @@ export class MorphToMany {
     }
     newExistenceQuery(parentTable, aggregate, callback) {
         const relatedTable = this.related.getTable();
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(this.parent.getConnection()).select(aggregate);
         query.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
         query.whereColumn(`${this.table}.${this.foreignPivotKey}`, "=", `${parentTable}.${this.parentKey}`);
         query.where(`${this.table}.${this.name}_type`, this.morphType);