@bunnykit/orm 0.1.5 → 0.1.6

package/dist/src/model/Model.js

@@ -5,6 +5,8 @@ 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();
@@ -32,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;
     }
@@ -46,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);
@@ -74,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);
     }
@@ -121,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);
     }
@@ -152,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);
@@ -184,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);
@@ -212,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)
@@ -250,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);
     }
@@ -293,6 +295,7 @@ export class Model {
     $exists = false;
     $relations = {};
     $casts = {};
+    $connection;
     constructor(attributes) {
         const defaults = this.constructor.attributes;
         if (Object.keys(defaults).length > 0) {
@@ -338,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;
@@ -613,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) {
@@ -745,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);
             }
@@ -768,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;
                 }
@@ -802,7 +833,8 @@ export class Model {
             return false;
         const now = this.freshTimestamp();
         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({ updated_at: now });
         this.$attributes["updated_at"] = now;
@@ -814,7 +846,8 @@ export class Model {
         const pk = this.getAttribute(constructor.primaryKey);
         if (!pk)
             return this;
-        const builder = new Builder(constructor.getConnection(), constructor.getTable())
+        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() };
@@ -843,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;
@@ -865,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;
@@ -878,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/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);

package/dist/src/query/Builder.d.ts

@@ -1,5 +1,5 @@
 import { Connection } from "../connection/Connection.js";
-import type { WhereClause, OrderClause } from "../types/index.js";
+import type { WhereClause, OrderClause, HavingClause, UnionClause } from "../types/index.js";
 import type { Model } from "../model/Model.js";
 type RelationConstraint = (query: Builder<any>) => void | Builder<any>;
 export interface Paginator<T> {
@@ -18,7 +18,7 @@ export declare class Builder<T = Record<string, any>> {
     wheres: WhereClause[];
     orders: OrderClause[];
     groups: string[];
-    havings: string[];
+    havings: HavingClause[];
     limitValue?: number;
     offsetValue?: number;
     joins: string[];
@@ -27,7 +27,11 @@ export declare class Builder<T = Record<string, any>> {
     eagerLoads: string[];
     randomOrderFlag: boolean;
     lockMode?: string;
+    unions: UnionClause[];
+    fromRaw?: string;
+    updateJoins: string[];
     constructor(connection: Connection, table: string);
+    private get grammar();
     setModel(model: typeof Model): this;
     table(table: string): this;
     select(...columns: string[]): this;
@@ -56,18 +60,44 @@ export declare class Builder<T = Record<string, any>> {
     whereRaw(sql: string, boolean?: "and" | "or", scope?: string): this;
     whereColumn(first: string, operator: string, second: string, boolean?: "and" | "or"): this;
     whereExists(sql: string, boolean?: "and" | "or", not?: boolean): this;
+    orWhereNull(column: string, scope?: string): this;
+    orWhereNotNull(column: string, scope?: string): this;
+    orWhereBetween(column: string, values: [any, any], scope?: string): this;
+    orWhereNotBetween(column: string, values: [any, any], scope?: string): this;
+    orWhereIn(column: string, values: any[], scope?: string): this;
+    orWhereNotIn(column: string, values: any[], scope?: string): this;
+    orWhereExists(sql: string): this;
+    orWhereNotExists(sql: string): this;
+    orWhereColumn(first: string, operator: string, second: string): this;
+    orWhereRaw(sql: string, scope?: string): this;
+    whereJsonContains(column: string, value: any, boolean?: "and" | "or", not?: boolean): this;
+    whereJsonLength(column: string, operator?: string | number, value?: number, boolean?: "and" | "or", not?: boolean): this;
+    whereLike(column: string, value: string, boolean?: "and" | "or", not?: boolean): this;
+    whereNotLike(column: string, value: string): this;
+    whereRegexp(column: string, value: string, boolean?: "and" | "or", not?: boolean): this;
+    whereFullText(columns: string | string[], value: string, boolean?: "and" | "or", not?: boolean): this;
+    whereAll(columns: string[], operator: string, value: any, boolean?: "and" | "or"): this;
+    whereAny(columns: string[], operator: string, value: any, boolean?: "and" | "or"): this;
     orderBy(column: string, direction?: "asc" | "desc"): this;
     latest(column?: string): this;
     oldest(column?: string): this;
     inRandomOrder(): this;
+    orderByDesc(column: string): this;
+    reorder(column?: string, direction?: "asc" | "desc"): this;
     groupBy(...columns: string[]): this;
     having(column: string, operator: string, value: any): this;
+    orHaving(column: string, operator: string, value: any): this;
+    havingRaw(sql: string, boolean?: "and" | "or"): this;
+    orHavingRaw(sql: string): this;
     limit(count: number): this;
     offset(count: number): this;
     forPage(page: number, perPage?: number): this;
     join(table: string, first: string, operator: string, second: string, type?: string): this;
     leftJoin(table: string, first: string, operator: string, second: string): this;
     rightJoin(table: string, first: string, operator: string, second: string): this;
+    crossJoin(table: string): this;
+    union(query: Builder<T> | string, all?: boolean): this;
+    unionAll(query: Builder<T> | string): this;
     with(...relations: string[]): this;
     withoutGlobalScope(scope: string): this;
     withoutGlobalScopes(): this;
@@ -89,12 +119,12 @@ export declare class Builder<T = Record<string, any>> {
     withMin(relationName: string, column: string, alias?: string): this;
     withMax(relationName: string, column: string, alias?: string): this;
     addSelect(...columns: string[]): this;
+    selectRaw(sql: string): this;
+    fromSub(query: Builder<any> | string, as: string): this;
+    updateFrom(table: string, first: string, operator: string, second: string): this;
     clone(): Builder<T>;
     wrapColumn(value: string): string;
     escapeValue(value: any): string;
-    private wrap;
-    private wrapValue;
-    private escape;
     private compileWhereClause;
     private compileWheres;
     private compileNestedWheres;
@@ -127,6 +157,8 @@ export declare class Builder<T = Record<string, any>> {
     lazy(count?: number): AsyncGenerator<T>;
     insert(data: Partial<T> | Partial<T>[]): Promise<any>;
     insertGetId(data: Partial<T>, idColumn?: string): Promise<any>;
+    insertOrIgnore(data: Partial<T> | Partial<T>[]): Promise<any>;
+    upsert(data: Partial<T> | Partial<T>[], uniqueBy: string | string[], updateColumns?: string[]): Promise<any>;
     update(data: Partial<T>): Promise<any>;
     delete(): Promise<any>;
     increment(column: string, amount?: number, extra?: Record<string, any>): Promise<any>;
@@ -134,10 +166,17 @@ export declare class Builder<T = Record<string, any>> {
     restore(): Promise<any>;
     exists(): Promise<boolean>;
     doesntExist(): Promise<boolean>;
+    sole(): Promise<T>;
+    value(column: string): Promise<any>;
+    dump(): this;
+    dd(): never;
+    explain(): Promise<any[]>;
     take(count: number): this;
     skip(count: number): this;
     lockForUpdate(): this;
     sharedLock(): this;
+    skipLocked(): this;
+    noWait(): this;
     private addDateWhere;
     private getModelRelation;
     private withAggregate;