@bunnykit/orm 0.1.20 → 0.1.21

package/dist/src/connection/ConnectionManager.js

@@ -28,12 +28,12 @@ export class ConnectionManager {
         }
         const now = Date.now();
         const idleTimeout = poolConfig.idleTimeout || 30000;
+        // Reuse a healthy idle connection
         while (pool.length > 0) {
             const idx = pool.findIndex((c) => !c.inUse && (now - c.lastUsed) < idleTimeout);
             if (idx === -1)
                 break;
             const pooled = pool[idx];
-            pool.splice(idx, 1);
             try {
                 await pooled.connection.query("SELECT 1");
                 pooled.inUse = true;
@@ -41,6 +41,14 @@ export class ConnectionManager {
             }
             catch {
                 await pooled.connection.close().catch(() => null);
+                pool.splice(idx, 1);
+            }
+        }
+        // Clean up expired idle connections
+        for (let i = pool.length - 1; i >= 0; i--) {
+            if (!pool[i].inUse && (now - pool[i].lastUsed) >= idleTimeout) {
+                await pool[i].connection.close().catch(() => null);
+                pool.splice(i, 1);
             }
         }
         if (pool.length < (poolConfig.maxConnections || 10)) {
@@ -203,6 +211,14 @@ export class ConnectionManager {
         this.connections.clear();
         this.pools.clear();
         this.tenantCache.clear();
+        // Reject all pending waiters
+        for (const [name, poolWaiters] of this.waiters) {
+            for (const waiter of poolWaiters) {
+                clearTimeout(waiter.timer);
+                waiter.reject(new Error(`Connection pool "${name}" is closing`));
+            }
+        }
+        this.waiters.clear();
         for (const connection of connections) {
             await connection.close();
         }

package/dist/src/model/BelongsToMany.js

@@ -23,6 +23,15 @@ export class BelongsToMany {
         this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
         this.builder = related.on(parent.getConnection());
         this.addConstraints();
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     addConstraints() {
         const relatedTable = this.related.getTable();

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

@@ -5,4 +5,5 @@ export declare class IdentityMap {
     static get(table: string, key: string | number): Model | undefined;
     static set(table: string, key: string | number, model: Model): void;
     static clear(): void;
+    static delete(table: string, key: string | number): void;
 }

package/dist/src/model/IdentityMap.js

@@ -25,4 +25,10 @@ export class IdentityMap {
             return;
         map.clear();
     }
+    static delete(table, key) {
+        const map = this.current();
+        if (!map)
+            return;
+        map.delete(`${table}:${String(key)}`);
+    }
 }

package/dist/src/model/Model.js

@@ -332,6 +332,29 @@ export class Model {
                 }
                 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) {
@@ -345,7 +368,17 @@ export class Model {
         });
     }
     syncAttributeProperties() {
-        for (const key of Object.keys(this.$attributes)) {
+        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);
         }
     }
@@ -918,6 +951,10 @@ export class Model {
                 .delete();
             this.$exists = false;
         }
+        const identityMap = IdentityMap.current();
+        if (identityMap) {
+            IdentityMap.delete(constructor.getTable(), pk);
+        }
         await ObserverRegistry.dispatch("deleted", this);
         return true;
     }
@@ -948,6 +985,10 @@ export class Model {
             .where(constructor.primaryKey, pk)
             .delete();
         this.$exists = false;
+        const identityMap = IdentityMap.current();
+        if (identityMap) {
+            IdentityMap.delete(constructor.getTable(), pk);
+        }
         return true;
     }
     async refresh() {
@@ -955,11 +996,20 @@ export class Model {
         const pk = this.getAttribute(constructor.primaryKey);
         if (!pk)
             return this;
+        // Bypass identity map to fetch fresh data
+        const identityMap = IdentityMap.current();
+        if (identityMap) {
+            IdentityMap.delete(constructor.getTable(), pk);
+        }
         const result = await constructor.find(pk);
         if (result) {
             this.$attributes = result.$attributes;
             this.$original = { ...result.$attributes };
             this.syncAttributeProperties();
+            // Ensure this instance is the canonical one in the identity map
+            if (identityMap) {
+                IdentityMap.set(constructor.getTable(), pk, this);
+            }
         }
         return this;
     }

package/dist/src/model/MorphRelations.js

@@ -13,6 +13,15 @@ export class MorphTo {
         this.typeColumn = `${name}_type`;
         this.idColumn = `${name}_id`;
         this.typeMap = typeMap;
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     async getResults() {
         const type = this.parent.getAttribute(this.typeColumn);
@@ -99,6 +108,15 @@ export class MorphOne {
         this.builder = related.on(parent.getConnection());
         this.builder.where(this.typeColumn, this.getMorphType());
         this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     getMorphType() {
         return this.parent.constructor.morphName || this.parent.constructor.name;
@@ -168,6 +186,15 @@ export class MorphMany {
         this.builder = related.on(parent.getConnection());
         this.builder.where(this.typeColumn, this.getMorphType());
         this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     getMorphType() {
         return this.parent.constructor.morphName || this.parent.constructor.name;
@@ -244,6 +271,15 @@ export class MorphToMany {
         this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
         this.builder = related.on(parent.getConnection());
         this.addConstraints();
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     addConstraints() {
         const relatedTable = this.related.getTable();

package/dist/src/query/Builder.js

@@ -182,10 +182,7 @@ export class Builder {
         return this.whereRaw(sql, "or", scope);
     }
     whereJsonContains(column, value, boolean = "and", not = false) {
-        let sql = this.grammar.compileJsonContains(this.grammar.wrap(column), value);
-        if (not)
-            sql = `NOT (${sql})`;
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        this.wheres.push({ type: "json_contains", column, value, boolean, scope: undefined, not });
         return this;
     }
     whereJsonLength(column, operator = "=", value, boolean = "and", not = false) {
@@ -193,41 +190,31 @@ export class Builder {
             value = operator;
             operator = "=";
         }
-        let sql = this.grammar.compileJsonLength(this.grammar.wrap(column), String(operator), value);
-        if (not)
-            sql = `NOT (${sql})`;
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        this.wheres.push({ type: "json_length", column, operator: String(operator), value, boolean, scope: undefined, not });
         return this;
     }
     whereLike(column, value, boolean = "and", not = false) {
-        const sql = this.grammar.compileLike(this.grammar.wrap(column), value, not);
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        this.wheres.push({ type: "like", column, value, boolean, scope: undefined, not });
         return this;
     }
     whereNotLike(column, value) {
         return this.whereLike(column, value, "and", true);
     }
     whereRegexp(column, value, boolean = "and", not = false) {
-        const sql = this.grammar.compileRegexp(this.grammar.wrap(column), value, not);
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        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];
-        let sql = this.grammar.compileFullText(cols.map((c) => this.grammar.wrap(c)), value);
-        if (not)
-            sql = `NOT (${sql})`;
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        this.wheres.push({ type: "fulltext", column: "", columns: cols, value, boolean, scope: undefined, not });
         return this;
     }
     whereAll(columns, operator, value, boolean = "and") {
-        const sql = columns.map((c) => `${this.grammar.wrap(c)} ${operator} ${this.grammar.escape(value)}`).join(" AND ");
-        this.wheres.push({ type: "raw", column: `(${sql})`, boolean, scope: undefined });
+        this.wheres.push({ type: "all", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     whereAny(columns, operator, value, boolean = "and") {
-        const sql = columns.map((c) => `${this.grammar.wrap(c)} ${operator} ${this.grammar.escape(value)}`).join(" OR ");
-        this.wheres.push({ type: "raw", column: `(${sql})`, boolean, scope: undefined });
+        this.wheres.push({ type: "any", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     orderBy(column, direction = "asc") {
@@ -459,6 +446,7 @@ export class Builder {
         cloned.fromRaw = this.fromRaw;
         cloned.updateJoins = [...this.updateJoins];
         cloned.bindings = [...this.bindings];
+        cloned.parameterize = this.parameterize;
         return cloned;
     }
     wrapColumn(value) {
@@ -496,6 +484,53 @@ export class Builder {
         else if (where.type === "raw") {
             return `${prefix} ${where.column}`;
         }
+        else if (where.type === "like") {
+            const sql = this.grammar.compileLike(this.grammar.wrap(where.column), where.value, !!where.not, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "regexp") {
+            const sql = this.grammar.compileRegexp(this.grammar.wrap(where.column), where.value, !!where.not, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "fulltext") {
+            const cols = (where.columns || []).map((c) => this.grammar.wrap(c));
+            let sql = this.grammar.compileFullText(cols, where.value, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            if (where.not)
+                sql = `NOT (${sql})`;
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "json_contains") {
+            let sql = this.grammar.compileJsonContains(this.grammar.wrap(where.column), where.value, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            if (where.not)
+                sql = `NOT (${sql})`;
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "json_length") {
+            let sql = this.grammar.compileJsonLength(this.grammar.wrap(where.column), where.operator || "=", where.value, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            if (where.not)
+                sql = `NOT (${sql})`;
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "date") {
+            const sql = this.grammar.compileDateWhere(where.dateType || "date", this.grammar.wrap(where.column), where.operator || "=", where.value, this.parameterize ? (v) => this.addBinding(v) : undefined);
+            return `${prefix} ${sql}`;
+        }
+        else if (where.type === "all") {
+            const cols = (where.columns || []).map((c) => this.grammar.wrap(c));
+            const inner = cols.map((c) => {
+                const val = this.parameterize ? this.addBinding(where.value) : this.grammar.escape(where.value);
+                return `${c} ${where.operator} ${val}`;
+            }).join(" AND ");
+            return `${prefix} (${inner})`;
+        }
+        else if (where.type === "any") {
+            const cols = (where.columns || []).map((c) => this.grammar.wrap(c));
+            const inner = cols.map((c) => {
+                const val = this.parameterize ? this.addBinding(where.value) : this.grammar.escape(where.value);
+                return `${c} ${where.operator} ${val}`;
+            }).join(" OR ");
+            return `${prefix} (${inner})`;
+        }
         else if (where.type === "column") {
             return `${prefix} ${this.grammar.wrap(where.column)} ${where.operator} ${this.grammar.wrap(where.value)}`;
         }
@@ -740,16 +775,34 @@ export class Builder {
     async *cursor(chunkSize = 1000) {
         const model = this.model;
         const primaryKey = model ? model.primaryKey || "id" : "id";
+        // Cursor pagination is incompatible with random ordering
+        if (this.randomOrderFlag) {
+            throw new Error("cursor() does not support inRandomOrder(). Use lazy() instead.");
+        }
         const orderColumn = this.orders[0]?.column || primaryKey;
         const orderDirection = this.orders[0]?.direction || "asc";
+        // Use unqualified column name for property access on model instances
+        const accessColumn = orderColumn.includes(".") ? orderColumn.split(".")[1] : orderColumn;
         let lastValue = undefined;
         while (true) {
             const builder = this.clone();
-            builder.orders = [{ column: orderColumn, direction: orderDirection }];
+            // Preserve multi-column ORDER BY, appending PK tie-breaker if not present
+            builder.orders = this.orders.length > 0 ? [...this.orders] : [{ column: orderColumn, direction: orderDirection }];
+            const hasPkOrder = builder.orders.some((o) => o.column === primaryKey);
+            if (!hasPkOrder) {
+                builder.orders.push({ column: primaryKey, direction: orderDirection });
+            }
             builder.offsetValue = undefined;
             builder.limitValue = chunkSize;
             if (lastValue !== undefined) {
                 const op = orderDirection === "asc" ? ">" : "<";
+                // Parenthesize existing wheres when appending cursor condition to preserve OR precedence
+                if (builder.wheres.length > 0) {
+                    const hasOr = builder.wheres.some((w) => w.boolean === "or");
+                    if (hasOr) {
+                        builder.wheres = [{ type: "raw", column: `(${builder.compileWheres().replace(/^WHERE /, "")})`, boolean: "and", scope: undefined }];
+                    }
+                }
                 builder.wheres.push({
                     type: "basic",
                     column: orderColumn,
@@ -769,7 +822,7 @@ export class Builder {
                 break;
             const lastItem = items[items.length - 1];
             lastValue = lastItem && typeof lastItem === "object"
-                ? lastItem[orderColumn]
+                ? lastItem[accessColumn]
                 : undefined;
         }
     }
@@ -958,8 +1011,7 @@ export class Builder {
             value = operator;
             operator = "=";
         }
-        const sql = this.grammar.compileDateWhere(type, this.grammar.wrap(column), operator, value);
-        this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
+        this.wheres.push({ type: "date", column: column, operator, value, boolean, scope: undefined, dateType: type });
         return this;
     }
     getModelRelation(relationName) {

package/dist/src/query/grammars/Grammar.d.ts

@@ -6,15 +6,15 @@ export declare abstract class Grammar {
     abstract compileRandomOrder(): string;
     compileOffset(offset: number, _limit?: number): string;
     compileLock(lockMode?: string): string;
-    abstract compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    abstract compileDateWhere(type: string, column: string, operator: string, value: any, binding?: (value: any) => string): string;
     abstract compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
     abstract compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
     compileUpdate(table: string, sets: string[], wheres: string, joins?: string[]): string;
     compileDelete(table: string, wheres: string, joins?: string[], limit?: number): string;
-    abstract compileJsonContains(column: string, value: any): string;
-    abstract compileJsonLength(column: string, operator: string, value: any): string;
-    compileLike(column: string, value: string, not: boolean): string;
-    abstract compileRegexp(column: string, value: string, not: boolean): string;
-    abstract compileFullText(columns: string[], value: string): string;
+    abstract compileJsonContains(column: string, value: any, binding?: (value: any) => string): string;
+    abstract compileJsonLength(column: string, operator: string, value: any, binding?: (value: any) => string): string;
+    compileLike(column: string, value: string, not: boolean, binding?: (value: any) => string): string;
+    abstract compileRegexp(column: string, value: string, not: boolean, binding?: (value: any) => string): string;
+    abstract compileFullText(columns: string[], value: string, binding?: (value: any) => string): string;
     abstract compileExplain(sql: string): string;
 }

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

@@ -40,8 +40,8 @@ export class Grammar {
             sql += ` LIMIT ${limit}`;
         return sql.trim();
     }
-    compileLike(column, value, not) {
+    compileLike(column, value, not, binding) {
         const op = not ? "NOT LIKE" : "LIKE";
-        return `${column} ${op} ${this.escape(value)}`;
+        return `${column} ${op} ${binding ? binding(value) : this.escape(value)}`;
     }
 }

package/dist/src/query/grammars/MySqlGrammar.d.ts

@@ -3,12 +3,12 @@ export declare class MySqlGrammar extends Grammar {
     wrap(value: string): string;
     placeholder(_index: number): string;
     compileRandomOrder(): string;
-    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any, binding?: (value: any) => string): string;
     compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
     compileUpsert(table: string, columns: string[], values: string[], _uniqueBy: string[], updateColumns: string[]): string;
-    compileJsonContains(column: string, value: any): string;
-    compileJsonLength(column: string, operator: string, value: any): string;
-    compileRegexp(column: string, value: string, not: boolean): string;
-    compileFullText(columns: string[], value: string): string;
+    compileJsonContains(column: string, value: any, binding?: (value: any) => string): string;
+    compileJsonLength(column: string, operator: string, value: any, binding?: (value: any) => string): string;
+    compileRegexp(column: string, value: string, not: boolean, binding?: (value: any) => string): string;
+    compileFullText(columns: string[], value: string, binding?: (value: any) => string): string;
     compileExplain(sql: string): string;
 }

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

@@ -18,20 +18,21 @@ export class MySqlGrammar extends Grammar {
     compileRandomOrder() {
         return "ORDER BY RAND()";
     }
-    compileDateWhere(type, column, operator, value) {
+    compileDateWhere(type, column, operator, value, binding) {
+        const val = binding ? binding(value) : this.escape(value);
         switch (type) {
             case "date":
-                return `DATE(${column}) ${operator} ${this.escape(value)}`;
+                return `DATE(${column}) ${operator} ${val}`;
             case "day":
-                return `DAY(${column}) ${operator} ${this.escape(value)}`;
+                return `DAY(${column}) ${operator} ${val}`;
             case "month":
-                return `MONTH(${column}) ${operator} ${this.escape(value)}`;
+                return `MONTH(${column}) ${operator} ${val}`;
             case "year":
-                return `YEAR(${column}) ${operator} ${this.escape(value)}`;
+                return `YEAR(${column}) ${operator} ${val}`;
             case "time":
-                return `TIME(${column}) ${operator} ${this.escape(value)}`;
+                return `TIME(${column}) ${operator} ${val}`;
             default:
-                return `${column} ${operator} ${this.escape(value)}`;
+                return `${column} ${operator} ${val}`;
         }
     }
     compileInsertOrIgnore(table, columns, values) {
@@ -43,18 +44,18 @@ export class MySqlGrammar extends Grammar {
             .join(", ");
         return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON DUPLICATE KEY UPDATE ${updateCols}`;
     }
-    compileJsonContains(column, value) {
-        return `JSON_CONTAINS(${column}, ${this.escape(JSON.stringify(value))})`;
+    compileJsonContains(column, value, binding) {
+        return `JSON_CONTAINS(${column}, ${binding ? binding(JSON.stringify(value)) : this.escape(JSON.stringify(value))})`;
     }
-    compileJsonLength(column, operator, value) {
-        return `JSON_LENGTH(${column}) ${operator} ${this.escape(value)}`;
+    compileJsonLength(column, operator, value, binding) {
+        return `JSON_LENGTH(${column}) ${operator} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileRegexp(column, value, not) {
+    compileRegexp(column, value, not, binding) {
         const op = not ? "NOT REGEXP" : "REGEXP";
-        return `${column} ${op} ${this.escape(value)}`;
+        return `${column} ${op} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileFullText(columns, value) {
-        return `MATCH (${columns.join(", ")}) AGAINST (${this.escape(value)})`;
+    compileFullText(columns, value, binding) {
+        return `MATCH (${columns.join(", ")}) AGAINST (${binding ? binding(value) : this.escape(value)})`;
     }
     compileExplain(sql) {
         return `EXPLAIN ${sql}`;

package/dist/src/query/grammars/PostgresGrammar.d.ts

@@ -3,12 +3,12 @@ export declare class PostgresGrammar extends Grammar {
     wrap(value: string): string;
     placeholder(index: number): string;
     compileRandomOrder(): string;
-    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any, binding?: (value: any) => string): string;
     compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
     compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
-    compileJsonContains(column: string, value: any): string;
-    compileJsonLength(column: string, operator: string, value: any): string;
-    compileRegexp(column: string, value: string, not: boolean): string;
-    compileFullText(columns: string[], value: string): string;
+    compileJsonContains(column: string, value: any, binding?: (value: any) => string): string;
+    compileJsonLength(column: string, operator: string, value: any, binding?: (value: any) => string): string;
+    compileRegexp(column: string, value: string, not: boolean, binding?: (value: any) => string): string;
+    compileFullText(columns: string[], value: string, binding?: (value: any) => string): string;
     compileExplain(sql: string): string;
 }

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

@@ -18,20 +18,21 @@ export class PostgresGrammar extends Grammar {
     compileRandomOrder() {
         return "ORDER BY RANDOM()";
     }
-    compileDateWhere(type, column, operator, value) {
+    compileDateWhere(type, column, operator, value, binding) {
+        const val = binding ? binding(value) : this.escape(value);
         switch (type) {
             case "date":
-                return `(${column})::date ${operator} ${this.escape(value)}`;
+                return `(${column})::date ${operator} ${val}`;
             case "day":
-                return `EXTRACT(DAY FROM ${column}) ${operator} ${this.escape(value)}`;
+                return `EXTRACT(DAY FROM ${column}) ${operator} ${val}`;
             case "month":
-                return `EXTRACT(MONTH FROM ${column}) ${operator} ${this.escape(value)}`;
+                return `EXTRACT(MONTH FROM ${column}) ${operator} ${val}`;
             case "year":
-                return `EXTRACT(YEAR FROM ${column}) ${operator} ${this.escape(value)}`;
+                return `EXTRACT(YEAR FROM ${column}) ${operator} ${val}`;
             case "time":
-                return `(${column})::time ${operator} ${this.escape(value)}`;
+                return `(${column})::time ${operator} ${val}`;
             default:
-                return `${column} ${operator} ${this.escape(value)}`;
+                return `${column} ${operator} ${val}`;
         }
     }
     compileInsertOrIgnore(table, columns, values) {
@@ -43,21 +44,21 @@ export class PostgresGrammar extends Grammar {
             .join(", ");
         return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON CONFLICT (${uniqueBy.map((c) => this.wrap(c)).join(", ")}) DO UPDATE SET ${updateCols}`;
     }
-    compileJsonContains(column, value) {
-        return `${column} @> ${this.escape(JSON.stringify([value]))}`;
+    compileJsonContains(column, value, binding) {
+        return `${column} @> ${binding ? binding(JSON.stringify([value])) : this.escape(JSON.stringify([value]))}`;
     }
-    compileJsonLength(column, operator, value) {
-        return `jsonb_array_length(${column}) ${operator} ${this.escape(value)}`;
+    compileJsonLength(column, operator, value, binding) {
+        return `jsonb_array_length(${column}) ${operator} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileRegexp(column, value, not) {
+    compileRegexp(column, value, not, binding) {
         const op = not ? "!~" : "~";
-        return `${column} ${op} ${this.escape(value)}`;
+        return `${column} ${op} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileFullText(columns, value) {
+    compileFullText(columns, value, binding) {
         const cols = columns.length > 1
             ? `concat_ws(' ', ${columns.join(", ")})`
             : columns[0];
-        return `to_tsvector('english', ${cols}) @@ plainto_tsquery('english', ${this.escape(value)})`;
+        return `to_tsvector('english', ${cols}) @@ plainto_tsquery('english', ${binding ? binding(value) : this.escape(value)})`;
     }
     compileExplain(sql) {
         return `EXPLAIN (FORMAT JSON) ${sql}`;

package/dist/src/query/grammars/SQLiteGrammar.d.ts

@@ -4,12 +4,12 @@ export declare class SQLiteGrammar extends Grammar {
     placeholder(_index: number): string;
     compileRandomOrder(): string;
     compileOffset(offset: number, limit?: number): string;
-    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any, binding?: (value: any) => string): string;
     compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
     compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
-    compileJsonContains(column: string, value: any): string;
-    compileJsonLength(column: string, operator: string, value: any): string;
-    compileRegexp(column: string, value: string, not: boolean): string;
-    compileFullText(columns: string[], value: string): string;
+    compileJsonContains(column: string, value: any, binding?: (value: any) => string): string;
+    compileJsonLength(column: string, operator: string, value: any, binding?: (value: any) => string): string;
+    compileRegexp(column: string, value: string, not: boolean, binding?: (value: any) => string): string;
+    compileFullText(columns: string[], value: string, binding?: (value: any) => string): string;
     compileExplain(sql: string): string;
 }

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

@@ -22,20 +22,21 @@ export class SQLiteGrammar extends Grammar {
         const limitSql = limit === undefined ? "LIMIT -1 " : "";
         return `${limitSql}OFFSET ${offset}`;
     }
-    compileDateWhere(type, column, operator, value) {
+    compileDateWhere(type, column, operator, value, binding) {
+        const val = binding ? binding(value) : this.escape(value);
         switch (type) {
             case "date":
-                return `date(${column}) ${operator} ${this.escape(value)}`;
+                return `date(${column}) ${operator} ${val}`;
             case "day":
-                return `CAST(strftime('%d', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+                return `CAST(strftime('%d', ${column}) AS INTEGER) ${operator} ${val}`;
             case "month":
-                return `CAST(strftime('%m', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+                return `CAST(strftime('%m', ${column}) AS INTEGER) ${operator} ${val}`;
             case "year":
-                return `CAST(strftime('%Y', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+                return `CAST(strftime('%Y', ${column}) AS INTEGER) ${operator} ${val}`;
             case "time":
-                return `time(${column}) ${operator} ${this.escape(value)}`;
+                return `time(${column}) ${operator} ${val}`;
             default:
-                return `${column} ${operator} ${this.escape(value)}`;
+                return `${column} ${operator} ${val}`;
         }
     }
     compileInsertOrIgnore(table, columns, values) {
@@ -47,18 +48,18 @@ export class SQLiteGrammar extends Grammar {
             .join(", ");
         return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON CONFLICT(${uniqueBy.map((c) => this.wrap(c)).join(", ")}) DO UPDATE SET ${updateCols}`;
     }
-    compileJsonContains(column, value) {
-        return `${column} IN (SELECT value FROM json_each(${column})) AND ${this.escape(value)} IN (SELECT value FROM json_each(${column}))`;
+    compileJsonContains(column, value, binding) {
+        return `${column} IN (SELECT value FROM json_each(${column})) AND ${binding ? binding(value) : this.escape(value)} IN (SELECT value FROM json_each(${column}))`;
     }
-    compileJsonLength(column, operator, value) {
-        return `(SELECT COUNT(*) FROM json_each(${column})) ${operator} ${this.escape(value)}`;
+    compileJsonLength(column, operator, value, binding) {
+        return `(SELECT COUNT(*) FROM json_each(${column})) ${operator} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileRegexp(column, value, not) {
+    compileRegexp(column, value, not, binding) {
         const op = not ? "NOT REGEXP" : "REGEXP";
-        return `${column} ${op} ${this.escape(value)}`;
+        return `${column} ${op} ${binding ? binding(value) : this.escape(value)}`;
     }
-    compileFullText(columns, value) {
-        return columns.map((c) => `${this.wrap(c)} LIKE ${this.escape(`%${value}%`)}`).join(" OR ");
+    compileFullText(columns, value, binding) {
+        return columns.map((c) => `${this.wrap(c)} LIKE ${binding ? binding(`%${value}%`) : this.escape(`%${value}%`)}`).join(" OR ");
     }
     compileExplain(sql) {
         return `EXPLAIN QUERY PLAN ${sql}`;

package/dist/src/types/index.d.ts

@@ -29,12 +29,15 @@ export interface ForeignKeyDefinition {
     onUpdate?: string;
 }
 export interface WhereClause {
-    type: "basic" | "in" | "null" | "raw" | "between" | "column" | "exists";
+    type: "basic" | "in" | "null" | "raw" | "between" | "column" | "exists" | "like" | "regexp" | "fulltext" | "json_contains" | "json_length" | "date" | "all" | "any";
     column: string;
+    columns?: string[];
     operator?: string;
     value?: any;
     boolean: "and" | "or";
     scope?: string;
+    not?: boolean;
+    dateType?: string;
 }
 export interface OrderClause {
     column: string;

package/package.json

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