@bunnykit/orm 0.1.23 → 0.1.24

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) {
@@ -819,6 +812,7 @@ export class Model {
             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();
             }
             if (Object.keys(dirty).length > 0) {
@@ -840,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);
@@ -847,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 !== "") {
@@ -856,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;
@@ -863,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);
@@ -879,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)
@@ -897,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 = {}) {
@@ -914,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 = {}) {
@@ -942,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();
@@ -971,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() {
@@ -1006,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;

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) {
@@ -725,6 +768,7 @@ export class Builder {
         query.offsetValue = undefined;
         query.eagerLoads = [];
         query.lockMode = undefined;
+        query.invalidateSqlCache();
         const result = await query.first();
         return result ? result[alias] : null;
     }
@@ -748,6 +792,7 @@ export class Builder {
         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 {
@@ -1023,6 +1068,7 @@ export class Builder {
     lockForUpdate() {
         const driver = this.connection.getDriverName();
         if (driver !== "sqlite") {
+            this.invalidateSqlCache();
             this.lockMode = "FOR UPDATE";
         }
         return this;
@@ -1030,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;
@@ -1054,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.23",
+  "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",