@bunnykit/orm 0.1.22 → 0.1.24

package/dist/src/connection/Connection.d.ts

@@ -9,6 +9,7 @@ export declare class Connection {
     private schema?;
     private ownsDriver;
     private transactionDepth;
+    private savepointId;
     constructor(config: ConnectionConfig, options?: {
         driver?: SQL;
         schema?: string;

package/dist/src/connection/Connection.js

@@ -10,6 +10,7 @@ export class Connection {
     schema;
     ownsDriver;
     transactionDepth = 0;
+    savepointId = 0;
     constructor(config, options = {}) {
         this.config = config;
         this.schema = options.schema || ("schema" in config ? config.schema : undefined);
@@ -83,16 +84,36 @@ export class Connection {
         return await this.driver.unsafe(sqlString, bindings);
     }
     async beginTransaction() {
-        await this.driver.unsafe("BEGIN");
+        if (this.transactionDepth === 0) {
+            await this.driver.unsafe("BEGIN");
+        }
+        else {
+            await this.driver.unsafe(`SAVEPOINT bunny_trans_${++this.savepointId}`);
+        }
         this.transactionDepth++;
     }
     async commit() {
-        await this.driver.unsafe("COMMIT");
-        this.transactionDepth = Math.max(0, this.transactionDepth - 1);
+        if (this.transactionDepth <= 0)
+            return;
+        if (this.transactionDepth === 1) {
+            await this.driver.unsafe("COMMIT");
+        }
+        else {
+            await this.driver.unsafe(`RELEASE SAVEPOINT bunny_trans_${this.savepointId--}`);
+        }
+        this.transactionDepth--;
     }
     async rollback() {
-        await this.driver.unsafe("ROLLBACK");
-        this.transactionDepth = Math.max(0, this.transactionDepth - 1);
+        if (this.transactionDepth <= 0)
+            return;
+        if (this.transactionDepth === 1) {
+            await this.driver.unsafe("ROLLBACK");
+        }
+        else {
+            await this.driver.unsafe(`ROLLBACK TO SAVEPOINT bunny_trans_${this.savepointId}`);
+            await this.driver.unsafe(`RELEASE SAVEPOINT bunny_trans_${this.savepointId--}`);
+        }
+        this.transactionDepth--;
     }
     isInTransaction() {
         return this.transactionDepth > 0;

package/dist/src/migration/Migrator.js

@@ -195,30 +195,30 @@ export class Migrator {
             const statements = [];
             for (const row of tables) {
                 const table = row[key];
-                const createRows = await this.connection.query(`SHOW CREATE TABLE ${table}`);
+                const createRows = await this.connection.query(`SHOW CREATE TABLE ${this.connection.getGrammar().wrap(table)}`);
                 statements.push(`${createRows[0]["Create Table"]};`);
             }
             return statements.join("\n\n") + "\n";
         }
         const schema = this.connection.getSchema() || "public";
-        const tables = await this.connection.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${schema}' AND table_type = 'BASE TABLE' ORDER BY table_name`);
+        const tables = await this.connection.query("SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE' ORDER BY table_name", [schema]);
         const statements = [];
         for (const tableRow of tables) {
             const table = tableRow.table_name;
             const columns = await this.connection.query(`SELECT column_name, data_type, is_nullable, column_default, character_maximum_length, numeric_precision, numeric_scale
          FROM information_schema.columns
-         WHERE table_schema = '${schema}' AND table_name = '${table}'
-         ORDER BY ordinal_position`);
+         WHERE table_schema = $1 AND table_name = $2
+         ORDER BY ordinal_position`, [schema, table]);
             const primaryKeys = await this.connection.query(`SELECT kcu.column_name
          FROM information_schema.table_constraints tc
          JOIN information_schema.key_column_usage kcu
            ON tc.constraint_name = kcu.constraint_name
           AND tc.table_schema = kcu.table_schema
           AND tc.table_name = kcu.table_name
-         WHERE tc.table_schema = '${schema}'
-           AND tc.table_name = '${table}'
+         WHERE tc.table_schema = $1
+           AND tc.table_name = $2
            AND tc.constraint_type = 'PRIMARY KEY'
-         ORDER BY kcu.ordinal_position`);
+         ORDER BY kcu.ordinal_position`, [schema, table]);
             const pkColumns = primaryKeys.map((row) => row.column_name);
             const columnSql = columns.map((column) => {
                 let type = String(column.data_type).toUpperCase();
@@ -228,7 +228,7 @@ export class Migrator {
                 else if ((type === "NUMERIC" || type === "DECIMAL") && column.numeric_precision) {
                     type = `${type}(${column.numeric_precision}${column.numeric_scale ? `, ${column.numeric_scale}` : ""})`;
                 }
-                let sql = `  "${column.column_name}" ${type}`;
+                let sql = `  ${this.connection.getGrammar().wrap(column.column_name)} ${type}`;
                 if (column.is_nullable === "NO")
                     sql += " NOT NULL";
                 if (column.column_default !== null && column.column_default !== undefined)
@@ -236,9 +236,9 @@ export class Migrator {
                 return sql;
             });
             if (pkColumns.length > 0) {
-                columnSql.push(`  PRIMARY KEY (${pkColumns.map((column) => `"${column}"`).join(", ")})`);
+                columnSql.push(`  PRIMARY KEY (${pkColumns.map((column) => this.connection.getGrammar().wrap(column)).join(", ")})`);
             }
-            statements.push(`CREATE TABLE "${schema}"."${table}" (\n${columnSql.join(",\n")}\n);`);
+            statements.push(`CREATE TABLE ${this.connection.getGrammar().wrap(`${schema}.${table}`)} (\n${columnSql.join(",\n")}\n);`);
         }
         return statements.join("\n\n") + "\n";
     }

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

@@ -5,7 +5,7 @@ import { BelongsToMany } from "./BelongsToMany.js";
 export type ModelConstructor<T extends Model = Model> = (new (...args: any[]) => T) & Omit<typeof Model, "prototype">;
 export type GlobalScope = (builder: Builder<any>, model: ModelConstructor) => void;
 export type LiteralUnion<T extends string> = T | (string & {});
-type BaseModelInstanceKey = "$attributes" | "$original" | "$exists" | "$relations" | "$casts" | "$connection" | "fill" | "setConnection" | "getConnection" | "isFillable" | "getAttribute" | "setAttribute" | "castAttribute" | "serializeCastAttribute" | "mergeCasts" | "getDirty" | "isDirty" | "save" | "updateTimestamps" | "touch" | "increment" | "decrement" | "load" | "delete" | "restore" | "forceDelete" | "refresh" | "toJSON" | "toString" | "freshTimestamp" | "setRelation" | "getRelation" | "hasMany" | "belongsTo" | "hasOne" | "hasManyThrough" | "hasOneThrough" | "belongsToMany" | "morphTo" | "morphOne" | "morphMany" | "morphToMany" | "morphedByMany";
+type BaseModelInstanceKey = "$attributes" | "$original" | "$exists" | "$relations" | "$casts" | "$castCache" | "$connection" | "fill" | "setConnection" | "getConnection" | "isFillable" | "getAttribute" | "setAttribute" | "castAttribute" | "serializeCastAttribute" | "mergeCasts" | "getDirty" | "isDirty" | "save" | "updateTimestamps" | "touch" | "increment" | "decrement" | "load" | "delete" | "restore" | "forceDelete" | "refresh" | "toJSON" | "toString" | "freshTimestamp" | "setRelation" | "getRelation" | "hasMany" | "belongsTo" | "hasOne" | "hasManyThrough" | "hasOneThrough" | "belongsToMany" | "morphTo" | "morphOne" | "morphMany" | "morphToMany" | "morphedByMany";
 export type ModelInstanceAttributeKeys<T> = Extract<Exclude<keyof T, BaseModelInstanceKey>, string>;
 export type ModelAttributes<T> = T extends {
     $attributes: Record<string, any>;
@@ -111,10 +111,9 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     $exists: boolean;
     $relations: Record<string, any>;
     $casts: Record<string, CastDefinition>;
+    $castCache: Record<string, any>;
     $connection?: Connection;
     constructor(attributes?: Partial<T>);
-    private defineAttributeProperty;
-    private syncAttributeProperties;
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
@@ -127,6 +126,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static applyGlobalScopes(builder: Builder<any>): void;
     static getQualifiedDeletedAtColumn(): string;
     static shouldAutoGeneratePrimaryKey(): Promise<boolean>;
+    static hydrate<M extends ModelConstructor>(this: M, row: Record<string, any>, connection?: Connection): InstanceType<M>;
     static create<M extends ModelConstructor>(this: M, attributes: ModelAttributeInput<InstanceType<M>>): Promise<InstanceType<M>>;
     static find<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M> | null>;
     static findOrFail<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M>>;

package/dist/src/model/Model.js

@@ -8,6 +8,44 @@ import { ModelNotFoundError } from "./ModelNotFoundError.js";
 import { ConnectionManager } from "../connection/ConnectionManager.js";
 import { TenantContext } from "../connection/TenantContext.js";
 import { IdentityMap } from "./IdentityMap.js";
+const modelProxyHandler = {
+    get(target, prop, receiver) {
+        if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
+            return target.getAttribute(prop);
+        }
+        return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+        if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
+            target.setAttribute(prop, value);
+            return true;
+        }
+        return Reflect.set(target, prop, value, receiver);
+    },
+    has(target, prop) {
+        if (typeof prop === "string" && prop in target.$attributes)
+            return true;
+        return Reflect.has(target, prop);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop === "string" && prop in target.$attributes) {
+            return {
+                enumerable: true,
+                configurable: true,
+                value: target.getAttribute(prop),
+            };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+    ownKeys(target) {
+        const keys = new Set(Reflect.ownKeys(target));
+        for (const key of Object.keys(target.$attributes)) {
+            if (!key.startsWith("$"))
+                keys.add(key);
+        }
+        return Array.from(keys);
+    },
+};
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -306,6 +344,7 @@ export class Model {
     $exists = false;
     $relations = {};
     $casts = {};
+    $castCache = {};
     $connection;
     constructor(attributes) {
         const defaults = this.constructor.attributes;
@@ -315,72 +354,7 @@ export class Model {
         if (attributes) {
             this.fill(attributes);
         }
-        this.syncAttributeProperties();
-        // Minimal Proxy fallback for dynamic property access on undefined keys.
-        // Pre-defined attribute getters/setters bypass the Proxy entirely.
-        return new Proxy(this, {
-            get(target, prop, receiver) {
-                if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
-                    return target.getAttribute(prop);
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-            set(target, prop, value, receiver) {
-                if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
-                    target.setAttribute(prop, value);
-                    return true;
-                }
-                return Reflect.set(target, prop, value, receiver);
-            },
-            has(target, prop) {
-                if (typeof prop === "string" && prop in target.$attributes)
-                    return true;
-                return Reflect.has(target, prop);
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                if (typeof prop === "string" && prop in target.$attributes) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: target.getAttribute(prop),
-                    };
-                }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
-            },
-            ownKeys(target) {
-                const keys = new Set(Reflect.ownKeys(target));
-                for (const key of Object.keys(target.$attributes)) {
-                    if (!key.startsWith("$"))
-                        keys.add(key);
-                }
-                return Array.from(keys);
-            },
-        });
-    }
-    defineAttributeProperty(key) {
-        if (key in this)
-            return;
-        Object.defineProperty(this, key, {
-            get: () => this.getAttribute(key),
-            set: (value) => this.setAttribute(key, value),
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    syncAttributeProperties() {
-        const currentKeys = new Set(Object.keys(this.$attributes));
-        // Remove stale attribute properties
-        for (const key of Reflect.ownKeys(this)) {
-            if (key.startsWith("$") || typeof key !== "string")
-                continue;
-            const desc = Object.getOwnPropertyDescriptor(this, key);
-            if (desc && desc.get && desc.configurable && !currentKeys.has(key)) {
-                delete this[key];
-            }
-        }
-        for (const key of currentKeys) {
-            this.defineAttributeProperty(key);
-        }
+        return new Proxy(this, modelProxyHandler);
     }
     static getTable() {
         return this.table || snakeCase(this.name) + "s";
@@ -459,6 +433,17 @@ export class Model {
         const numericTypes = new Set(["integer", "int", "bigint", "smallint", "tinyint", "real", "float", "double", "decimal", "numeric"]);
         return !numericTypes.has(type);
     }
+    static hydrate(row, connection) {
+        const instance = new this();
+        instance.$attributes = { ...instance.$attributes, ...row };
+        instance.$original = { ...row };
+        instance.$castCache = {};
+        instance.$exists = true;
+        if (connection) {
+            instance.setConnection(connection);
+        }
+        return instance;
+    }
     static async create(attributes) {
         const instance = new this();
         instance.fill(attributes);
@@ -701,12 +686,19 @@ export class Model {
         return true;
     }
     getAttribute(key) {
+        if (Object.prototype.hasOwnProperty.call(this.$castCache, key)) {
+            return this.$castCache[key];
+        }
         const value = this.$attributes[key];
-        return this.castAttribute(key, value);
+        const casted = this.castAttribute(key, value);
+        if (this.getCastDefinition(key) && value !== null && value !== undefined) {
+            this.$castCache[key] = casted;
+        }
+        return casted;
     }
     setAttribute(key, value) {
         this.$attributes[key] = this.serializeCastAttribute(key, value);
-        this.defineAttributeProperty(key);
+        delete this.$castCache[key];
     }
     castAttribute(key, value) {
         const cast = this.getCastDefinition(key);
@@ -785,6 +777,7 @@ export class Model {
     }
     mergeCasts(casts) {
         this.$casts = { ...this.$casts, ...casts };
+        this.$castCache = {};
         return this;
     }
     getCastDefinition(key) {
@@ -815,21 +808,23 @@ export class Model {
     async save() {
         const constructor = this.constructor;
         if (this.$exists) {
-            await ObserverRegistry.dispatch("updating", this);
             await ObserverRegistry.dispatch("saving", this);
-            if (constructor.timestamps) {
+            let dirty = this.getDirty();
+            if (Object.keys(dirty).length > 0 && constructor.timestamps) {
                 this.$attributes["updated_at"] = this.freshTimestamp();
+                delete this.$castCache.updated_at;
+                dirty = this.getDirty();
             }
-            const dirty = this.getDirty();
             if (Object.keys(dirty).length > 0) {
+                await ObserverRegistry.dispatch("updating", this);
                 const pk = this.getAttribute(constructor.primaryKey);
                 const connection = this.getConnection();
                 await new Builder(connection, connection.qualifyTable(constructor.getTable()))
                     .where(constructor.primaryKey, pk)
                     .update(dirty);
+                await ObserverRegistry.dispatch("updated", this);
             }
             this.$original = { ...this.$attributes };
-            await ObserverRegistry.dispatch("updated", this);
             await ObserverRegistry.dispatch("saved", this);
         }
         else {
@@ -839,6 +834,8 @@ export class Model {
                 const now = this.freshTimestamp();
                 this.$attributes["created_at"] = now;
                 this.$attributes["updated_at"] = now;
+                delete this.$castCache.created_at;
+                delete this.$castCache.updated_at;
             }
             const primaryKey = constructor.primaryKey;
             const primaryKeyValue = this.getAttribute(primaryKey);
@@ -846,6 +843,7 @@ export class Model {
             if ((primaryKeyValue === null || primaryKeyValue === undefined || primaryKeyValue === "") && shouldGeneratePrimaryKey) {
                 const generated = crypto.randomUUID();
                 this.$attributes[primaryKey] = generated;
+                delete this.$castCache[primaryKey];
             }
             const connection = this.getConnection();
             if (shouldGeneratePrimaryKey || primaryKeyValue !== null && primaryKeyValue !== undefined && primaryKeyValue !== "") {
@@ -855,6 +853,7 @@ export class Model {
                 const result = await new Builder(connection, connection.qualifyTable(constructor.getTable())).insertGetId(this.$attributes);
                 if (result) {
                     this.$attributes[constructor.primaryKey] = result;
+                    delete this.$castCache[constructor.primaryKey];
                 }
             }
             this.$exists = true;
@@ -862,7 +861,6 @@ export class Model {
             await ObserverRegistry.dispatch("created", this);
             await ObserverRegistry.dispatch("saved", this);
         }
-        this.syncAttributeProperties();
         const identityMap = IdentityMap.current();
         if (identityMap) {
             const pk = this.getAttribute(constructor.primaryKey);
@@ -878,10 +876,11 @@ export class Model {
             return;
         const now = this.freshTimestamp();
         this.$attributes["updated_at"] = now;
+        delete this.$castCache.updated_at;
         if (!this.$exists) {
             this.$attributes["created_at"] = now;
+            delete this.$castCache.created_at;
         }
-        this.syncAttributeProperties();
     }
     async touch() {
         if (!this.$exists)
@@ -896,8 +895,8 @@ export class Model {
             .where(constructor.primaryKey, pk)
             .update({ updated_at: now });
         this.$attributes["updated_at"] = now;
+        delete this.$castCache.updated_at;
         this.$original = { ...this.$attributes };
-        this.syncAttributeProperties();
         return true;
     }
     async increment(column, amount = 1, extra = {}) {
@@ -913,11 +912,12 @@ export class Model {
         }
         await builder.increment(column, amount, extra);
         this.$attributes[column] = (this.$attributes[column] || 0) + amount;
+        delete this.$castCache[column];
         for (const [key, value] of Object.entries(extra)) {
             this.$attributes[key] = value;
+            delete this.$castCache[key];
         }
         this.$original = { ...this.$attributes };
-        this.syncAttributeProperties();
         return this;
     }
     async decrement(column, amount = 1, extra = {}) {
@@ -930,10 +930,10 @@ export class Model {
     }
     async delete() {
         const constructor = this.constructor;
-        await ObserverRegistry.dispatch("deleting", this);
         const pk = this.getAttribute(constructor.primaryKey);
         if (!pk)
             return false;
+        await ObserverRegistry.dispatch("deleting", this);
         if (constructor.softDeletes) {
             const deletedAt = this.freshTimestamp();
             const connection = this.getConnection();
@@ -941,8 +941,8 @@ export class Model {
                 .where(constructor.primaryKey, pk)
                 .update({ [constructor.deletedAtColumn]: deletedAt });
             this.$attributes[constructor.deletedAtColumn] = deletedAt;
+            delete this.$castCache[constructor.deletedAtColumn];
             this.$original = { ...this.$attributes };
-            this.syncAttributeProperties();
         }
         else {
             const connection = this.getConnection();
@@ -970,9 +970,9 @@ export class Model {
             .where(constructor.primaryKey, pk)
             .update({ [constructor.deletedAtColumn]: null });
         this.$attributes[constructor.deletedAtColumn] = null;
+        delete this.$castCache[constructor.deletedAtColumn];
         this.$original = { ...this.$attributes };
         this.$exists = true;
-        this.syncAttributeProperties();
         return true;
     }
     async forceDelete() {
@@ -1005,7 +1005,7 @@ export class Model {
         if (result) {
             this.$attributes = result.$attributes;
             this.$original = { ...result.$attributes };
-            this.syncAttributeProperties();
+            this.$castCache = {};
             // Ensure this instance is the canonical one in the identity map
             if (identityMap) {
                 IdentityMap.set(constructor.getTable(), pk, this);

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

@@ -32,8 +32,10 @@ export declare class Builder<T = Record<string, any>> {
     updateJoins: string[];
     bindings: any[];
     private parameterize;
+    private sqlCache?;
     constructor(connection: Connection, table: string);
     private get grammar();
+    private invalidateSqlCache;
     setModel(model: ModelConstructor): this;
     table(table: string): this;
     select(...columns: ModelColumn<T>[]): this;
@@ -168,6 +170,7 @@ export declare class Builder<T = Record<string, any>> {
     insertGetId(data: ModelAttributeInput<T>, idColumn?: ModelColumn<T>): Promise<any>;
     insertOrIgnore(data: ModelAttributeInput<T> | ModelAttributeInput<T>[]): Promise<any>;
     upsert(data: ModelAttributeInput<T> | ModelAttributeInput<T>[], uniqueBy: ModelColumn<T> | ModelColumn<T>[], updateColumns?: ModelColumn<T>[]): Promise<any>;
+    private getUniformColumns;
     update(data: ModelAttributeInput<T>): Promise<any>;
     delete(): Promise<any>;
     increment(column: ModelColumn<T>, amount?: number, extra?: ModelAttributeInput<T>): Promise<any>;

package/dist/src/query/Builder.js

@@ -21,6 +21,7 @@ export class Builder {
     updateJoins = [];
     bindings = [];
     parameterize = false;
+    sqlCache;
     constructor(connection, table) {
         this.connection = connection;
         this.tableName = table;
@@ -28,19 +29,25 @@ export class Builder {
     get grammar() {
         return this.connection.getGrammar();
     }
+    invalidateSqlCache() {
+        this.sqlCache = undefined;
+    }
     setModel(model) {
         this.model = model;
         return this;
     }
     table(table) {
+        this.invalidateSqlCache();
         this.tableName = table;
         return this;
     }
     select(...columns) {
+        this.invalidateSqlCache();
         this.columns = columns;
         return this;
     }
     distinct() {
+        this.invalidateSqlCache();
         this.distinctFlag = true;
         return this;
     }
@@ -58,6 +65,7 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "basic", column, operator, value, boolean, scope });
         return this;
     }
@@ -65,6 +73,7 @@ export class Builder {
         const nested = new Builder(this.connection, this.tableName);
         callback(nested);
         if (nested.wheres.length > 0) {
+            this.invalidateSqlCache();
             this.wheres.push({ type: "nested", column: "", query: nested.wheres, boolean, scope: undefined });
         }
         return this;
@@ -85,26 +94,32 @@ export class Builder {
         return this.whereNot(column, value, "or");
     }
     whereIn(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "in", column, value: values, boolean, scope });
         return this;
     }
     whereNotIn(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "in", column, value: values, boolean, operator: "NOT IN", scope });
         return this;
     }
     whereNull(column, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "null", column, boolean, scope });
         return this;
     }
     whereNotNull(column, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "null", column, boolean, operator: "NOT NULL", scope });
         return this;
     }
     whereBetween(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "between", column, value: values, boolean, scope });
         return this;
     }
     whereNotBetween(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "between", column, value: values, boolean, operator: "NOT BETWEEN", scope });
         return this;
     }
@@ -139,14 +154,17 @@ export class Builder {
         return this.whereTime(column, operator, value, "or");
     }
     whereRaw(sql, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "raw", column: sql, boolean, scope });
         return this;
     }
     whereColumn(first, operator, second, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "column", column: first, operator, value: second, boolean });
         return this;
     }
     whereExists(sql, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "exists", column: sql, boolean, operator: not ? "NOT EXISTS" : "EXISTS" });
         return this;
     }
@@ -181,6 +199,7 @@ export class Builder {
         return this.whereRaw(sql, "or", scope);
     }
     whereJsonContains(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "json_contains", column, value, boolean, scope: undefined, not });
         return this;
     }
@@ -189,10 +208,12 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "json_length", column, operator: String(operator), value, boolean, scope: undefined, not });
         return this;
     }
     whereLike(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "like", column, value, boolean, scope: undefined, not });
         return this;
     }
@@ -200,23 +221,28 @@ export class Builder {
         return this.whereLike(column, value, "and", true);
     }
     whereRegexp(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "regexp", column, value, boolean, scope: undefined, not });
         return this;
     }
     whereFullText(columns, value, boolean = "and", not = false) {
         const cols = Array.isArray(columns) ? columns : [columns];
+        this.invalidateSqlCache();
         this.wheres.push({ type: "fulltext", column: "", columns: cols, value, boolean, scope: undefined, not });
         return this;
     }
     whereAll(columns, operator, value, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "all", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     whereAny(columns, operator, value, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "any", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     orderBy(column, direction = "asc") {
+        this.invalidateSqlCache();
         this.orders.push({ column, direction });
         return this;
     }
@@ -227,6 +253,7 @@ export class Builder {
         return this.orderBy(column, "asc");
     }
     inRandomOrder() {
+        this.invalidateSqlCache();
         this.randomOrderFlag = true;
         return this;
     }
@@ -234,6 +261,7 @@ export class Builder {
         return this.orderBy(column, "desc");
     }
     reorder(column, direction = "asc") {
+        this.invalidateSqlCache();
         this.orders = [];
         this.randomOrderFlag = false;
         if (column) {
@@ -242,18 +270,22 @@ export class Builder {
         return this;
     }
     groupBy(...columns) {
+        this.invalidateSqlCache();
         this.groups.push(...columns);
         return this;
     }
     having(column, operator, value) {
+        this.invalidateSqlCache();
         this.havings.push({ column, operator, value, boolean: "and" });
         return this;
     }
     orHaving(column, operator, value) {
+        this.invalidateSqlCache();
         this.havings.push({ column, operator, value, boolean: "or" });
         return this;
     }
     havingRaw(sql, boolean = "and") {
+        this.invalidateSqlCache();
         this.havings.push({ sql, boolean });
         return this;
     }
@@ -261,10 +293,12 @@ export class Builder {
         return this.havingRaw(sql, "or");
     }
     limit(count) {
+        this.invalidateSqlCache();
         this.limitValue = count;
         return this;
     }
     offset(count) {
+        this.invalidateSqlCache();
         this.offsetValue = count;
         return this;
     }
@@ -273,6 +307,7 @@ export class Builder {
     }
     join(table, first, operator, second, type = "INNER") {
         const joinSql = `${type} JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`;
+        this.invalidateSqlCache();
         this.joins.push(joinSql);
         return this;
     }
@@ -283,11 +318,13 @@ export class Builder {
         return this.join(table, first, operator, second, "RIGHT");
     }
     crossJoin(table) {
+        this.invalidateSqlCache();
         this.joins.push(`CROSS JOIN ${this.grammar.wrap(table)}`);
         return this;
     }
     union(query, all = false) {
         const sql = typeof query === "string" ? query : query.toSql();
+        this.invalidateSqlCache();
         this.unions.push({ query: sql, all });
         return this;
     }
@@ -299,10 +336,12 @@ export class Builder {
         return this;
     }
     withoutGlobalScope(scope) {
+        this.invalidateSqlCache();
         this.wheres = this.wheres.filter((where) => where.scope !== scope);
         return this;
     }
     withoutGlobalScopes() {
+        this.invalidateSqlCache();
         this.wheres = this.wheres.filter((where) => !where.scope);
         return this;
     }
@@ -407,6 +446,7 @@ export class Builder {
         return this.withAggregate(relationName, column, "MAX", alias);
     }
     addSelect(...columns) {
+        this.invalidateSqlCache();
         if (this.columns.length === 1 && this.columns[0] === "*") {
             this.columns = [`${this.tableName}.*`];
         }
@@ -414,15 +454,18 @@ export class Builder {
         return this;
     }
     selectRaw(sql) {
+        this.invalidateSqlCache();
         this.columns.push(sql);
         return this;
     }
     fromSub(query, as) {
         const sql = typeof query === "string" ? query : query.toSql();
+        this.invalidateSqlCache();
         this.fromRaw = `(${sql}) AS ${this.grammar.wrap(as)}`;
         return this;
     }
     updateFrom(table, first, operator, second) {
+        this.invalidateSqlCache();
         this.updateJoins.push(`INNER JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`);
         return this;
     }
@@ -598,6 +641,8 @@ export class Builder {
         return column.includes("(") || /\s+as\s+/i.test(column) || /^[0-9]+$/.test(column);
     }
     toSql() {
+        if (!this.parameterize && this.sqlCache)
+            return this.sqlCache;
         const distinct = this.distinctFlag ? "DISTINCT " : "";
         const from = this.fromRaw || this.grammar.wrap(this.tableName);
         let sql = `SELECT ${distinct}${this.compileColumns()} FROM ${from}`;
@@ -613,7 +658,10 @@ export class Builder {
         for (const union of this.unions) {
             sql += ` UNION${union.all ? " ALL" : ""} ${union.query}`;
         }
-        return sql.replace(/\s+/g, " ").trim();
+        const compiled = sql.replace(/\s+/g, " ").trim();
+        if (!this.parameterize)
+            this.sqlCache = compiled;
+        return compiled;
     }
     async get() {
         this.bindings = [];
@@ -636,12 +684,7 @@ export class Builder {
                         }
                     }
                 }
-                const instance = new this.model(row);
-                instance.$exists = true;
-                instance.$original = { ...row };
-                if (typeof instance.setConnection === "function") {
-                    instance.setConnection(this.connection);
-                }
+                const instance = this.model.hydrate(row, this.connection);
                 if (identityMap) {
                     const pk = row[primaryKey];
                     if (pk !== null && pk !== undefined) {
@@ -717,10 +760,16 @@ export class Builder {
         return results.map((row) => row[column]);
     }
     async aggregate(sql, alias) {
-        const model = this.model;
-        this.model = undefined;
-        const result = await this.select(`${sql} as ${alias}`).first();
-        this.model = model;
+        const query = this.clone();
+        query.model = undefined;
+        query.columns = [`${sql} as ${alias}`];
+        query.orders = [];
+        query.limitValue = undefined;
+        query.offsetValue = undefined;
+        query.eagerLoads = [];
+        query.lockMode = undefined;
+        query.invalidateSqlCache();
+        const result = await query.first();
         return result ? result[alias] : null;
     }
     async count(column = "*") {
@@ -739,7 +788,12 @@ export class Builder {
         return await this.aggregate(`MAX(${column})`, "max");
     }
     async paginate(perPage = 15, page = 1) {
-        const total = await this.clone().count();
+        const countQuery = this.clone();
+        countQuery.limitValue = undefined;
+        countQuery.offsetValue = undefined;
+        countQuery.orders = [];
+        countQuery.invalidateSqlCache();
+        const total = await countQuery.count();
         const data = await this.clone().forPage(page, perPage).get();
         return {
             data,
@@ -867,7 +921,7 @@ export class Builder {
         const records = Array.isArray(data) ? data : [data];
         if (records.length === 0)
             return;
-        const columns = Object.keys(records[0]);
+        const columns = this.getUniformColumns(records);
         const bindings = [];
         const values = records.map((record) => {
             return `(${columns.map((col) => {
@@ -886,7 +940,7 @@ export class Builder {
         const records = Array.isArray(data) ? data : [data];
         if (records.length === 0)
             return;
-        const columns = Object.keys(records[0]);
+        const columns = this.getUniformColumns(records);
         const bindings = [];
         const values = records.map((record) => {
             return `(${columns.map((col) => {
@@ -901,7 +955,7 @@ export class Builder {
         const records = Array.isArray(data) ? data : [data];
         if (records.length === 0)
             return;
-        const columns = Object.keys(records[0]);
+        const columns = this.getUniformColumns(records);
         const bindings = [];
         const values = records.map((record) => {
             return `(${columns.map((col) => {
@@ -914,6 +968,17 @@ export class Builder {
         const sql = this.grammar.compileUpsert(this.grammar.wrap(this.tableName), columns, values, uniqueCols, updateCols);
         return await this.connection.run(sql, bindings);
     }
+    getUniformColumns(records) {
+        const columns = Object.keys(records[0]);
+        const signature = [...columns].sort().join("\0");
+        for (let i = 1; i < records.length; i++) {
+            const recordSignature = Object.keys(records[i]).sort().join("\0");
+            if (recordSignature !== signature) {
+                throw new Error("Bulk insert records must have the same columns.");
+            }
+        }
+        return columns;
+    }
     async update(data) {
         this.bindings = [];
         this.parameterize = true;
@@ -1003,6 +1068,7 @@ export class Builder {
     lockForUpdate() {
         const driver = this.connection.getDriverName();
         if (driver !== "sqlite") {
+            this.invalidateSqlCache();
             this.lockMode = "FOR UPDATE";
         }
         return this;
@@ -1010,21 +1076,25 @@ export class Builder {
     sharedLock() {
         const driver = this.connection.getDriverName();
         if (driver === "mysql") {
+            this.invalidateSqlCache();
             this.lockMode = "LOCK IN SHARE MODE";
         }
         else if (driver === "postgres") {
+            this.invalidateSqlCache();
             this.lockMode = "FOR SHARE";
         }
         return this;
     }
     skipLocked() {
         if (this.lockMode) {
+            this.invalidateSqlCache();
             this.lockMode += " SKIP LOCKED";
         }
         return this;
     }
     noWait() {
         if (this.lockMode) {
+            this.invalidateSqlCache();
             this.lockMode += " NOWAIT";
         }
         return this;
@@ -1034,6 +1104,7 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "date", column: column, operator, value, boolean, scope: undefined, dateType: type });
         return this;
     }

package/dist/src/query/grammars/MySqlGrammar.js

@@ -10,7 +10,7 @@ export class MySqlGrammar extends Grammar {
         }
         if (value === "*")
             return value;
-        return `\`${value}\``;
+        return `\`${value.replaceAll("`", "``")}\``;
     }
     placeholder(_index) {
         return "?";

package/dist/src/query/grammars/PostgresGrammar.js

@@ -10,7 +10,7 @@ export class PostgresGrammar extends Grammar {
         }
         if (value === "*")
             return value;
-        return `"${value}"`;
+        return `"${value.replaceAll('"', '""')}"`;
     }
     placeholder(index) {
         return `$${index}`;

package/dist/src/query/grammars/SQLiteGrammar.js

@@ -10,7 +10,7 @@ export class SQLiteGrammar extends Grammar {
         }
         if (value === "*")
             return value;
-        return `"${value}"`;
+        return `"${value.replaceAll('"', '""')}"`;
     }
     placeholder(_index) {
         return "?";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",