@bunnykit/orm 0.1.4 → 0.1.6

package/dist/src/query/Builder.js

@@ -1,3 +1,4 @@
+import { ModelNotFoundError } from "../model/ModelNotFoundError.js";
 export class Builder {
     connection;
     tableName;
@@ -12,10 +13,18 @@ export class Builder {
     distinctFlag = false;
     model;
     eagerLoads = [];
+    randomOrderFlag = false;
+    lockMode;
+    unions = [];
+    fromRaw;
+    updateJoins = [];
     constructor(connection, table) {
         this.connection = connection;
         this.tableName = table;
     }
+    get grammar() {
+        return this.connection.getGrammar();
+    }
     setModel(model) {
         this.model = model;
         return this;
@@ -33,6 +42,9 @@ export class Builder {
         return this;
     }
     where(column, operator, value, boolean = "and", scope) {
+        if (typeof column === "function") {
+            return this.whereNested(column, boolean);
+        }
         if (typeof column === "object" && column !== null) {
             for (const [key, val] of Object.entries(column)) {
                 this.where(key, "=", val, boolean, scope);
@@ -46,9 +58,30 @@ export class Builder {
         this.wheres.push({ type: "basic", column, operator, value, boolean, scope });
         return this;
     }
+    whereNested(callback, boolean = "and") {
+        const nested = new Builder(this.connection, this.tableName);
+        callback(nested);
+        if (nested.wheres.length > 0) {
+            const sql = this.compileNestedWheres(nested);
+            this.wheres.push({ type: "raw", column: `(${sql})`, boolean, scope: undefined });
+        }
+        return this;
+    }
     orWhere(column, operator, value) {
         return this.where(column, operator, value, "or");
     }
+    whereNot(column, value, boolean = "and") {
+        if (typeof column === "object" && column !== null) {
+            for (const [key, val] of Object.entries(column)) {
+                this.whereNot(key, val, boolean);
+            }
+            return this;
+        }
+        return this.where(column, "!=", value, boolean);
+    }
+    orWhereNot(column, value) {
+        return this.whereNot(column, value, "or");
+    }
     whereIn(column, values, boolean = "and", scope) {
         this.wheres.push({ type: "in", column, value: values, boolean, scope });
         return this;
@@ -73,6 +106,36 @@ export class Builder {
         this.wheres.push({ type: "between", column, value: values, boolean, operator: "NOT BETWEEN", scope });
         return this;
     }
+    whereDate(column, operator, value, boolean = "and") {
+        return this.addDateWhere("date", column, operator, value, boolean);
+    }
+    orWhereDate(column, operator, value) {
+        return this.whereDate(column, operator, value, "or");
+    }
+    whereDay(column, operator, value, boolean = "and") {
+        return this.addDateWhere("day", column, operator, value, boolean);
+    }
+    orWhereDay(column, operator, value) {
+        return this.whereDay(column, operator, value, "or");
+    }
+    whereMonth(column, operator, value, boolean = "and") {
+        return this.addDateWhere("month", column, operator, value, boolean);
+    }
+    orWhereMonth(column, operator, value) {
+        return this.whereMonth(column, operator, value, "or");
+    }
+    whereYear(column, operator, value, boolean = "and") {
+        return this.addDateWhere("year", column, operator, value, boolean);
+    }
+    orWhereYear(column, operator, value) {
+        return this.whereYear(column, operator, value, "or");
+    }
+    whereTime(column, operator, value, boolean = "and") {
+        return this.addDateWhere("time", column, operator, value, boolean);
+    }
+    orWhereTime(column, operator, value) {
+        return this.whereTime(column, operator, value, "or");
+    }
     whereRaw(sql, boolean = "and", scope) {
         this.wheres.push({ type: "raw", column: sql, boolean, scope });
         return this;
@@ -85,18 +148,129 @@ export class Builder {
         this.wheres.push({ type: "exists", column: sql, boolean, operator: not ? "NOT EXISTS" : "EXISTS" });
         return this;
     }
+    orWhereNull(column, scope) {
+        return this.whereNull(column, "or", scope);
+    }
+    orWhereNotNull(column, scope) {
+        return this.whereNotNull(column, "or", scope);
+    }
+    orWhereBetween(column, values, scope) {
+        return this.whereBetween(column, values, "or", scope);
+    }
+    orWhereNotBetween(column, values, scope) {
+        return this.whereNotBetween(column, values, "or", scope);
+    }
+    orWhereIn(column, values, scope) {
+        return this.whereIn(column, values, "or", scope);
+    }
+    orWhereNotIn(column, values, scope) {
+        return this.whereNotIn(column, values, "or", scope);
+    }
+    orWhereExists(sql) {
+        return this.whereExists(sql, "or");
+    }
+    orWhereNotExists(sql) {
+        return this.whereExists(sql, "or", true);
+    }
+    orWhereColumn(first, operator, second) {
+        return this.whereColumn(first, operator, second, "or");
+    }
+    orWhereRaw(sql, scope) {
+        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 });
+        return this;
+    }
+    whereJsonLength(column, operator = "=", value, boolean = "and", not = false) {
+        if (value === undefined) {
+            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 });
+        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 });
+        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 });
+        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 });
+        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 });
+        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 });
+        return this;
+    }
     orderBy(column, direction = "asc") {
         this.orders.push({ column, direction });
         return this;
     }
+    latest(column = "created_at") {
+        return this.orderBy(column, "desc");
+    }
+    oldest(column = "created_at") {
+        return this.orderBy(column, "asc");
+    }
+    inRandomOrder() {
+        this.randomOrderFlag = true;
+        return this;
+    }
+    orderByDesc(column) {
+        return this.orderBy(column, "desc");
+    }
+    reorder(column, direction = "asc") {
+        this.orders = [];
+        this.randomOrderFlag = false;
+        if (column) {
+            this.orderBy(column, direction);
+        }
+        return this;
+    }
     groupBy(...columns) {
         this.groups.push(...columns);
         return this;
     }
     having(column, operator, value) {
-        this.havings.push(`${this.wrap(column)} ${operator} ${this.escape(value)}`);
+        this.havings.push({ sql: `${this.grammar.wrap(column)} ${operator} ${this.grammar.escape(value)}`, boolean: "and" });
+        return this;
+    }
+    orHaving(column, operator, value) {
+        this.havings.push({ sql: `${this.grammar.wrap(column)} ${operator} ${this.grammar.escape(value)}`, boolean: "or" });
+        return this;
+    }
+    havingRaw(sql, boolean = "and") {
+        this.havings.push({ sql, boolean });
         return this;
     }
+    orHavingRaw(sql) {
+        return this.havingRaw(sql, "or");
+    }
     limit(count) {
         this.limitValue = count;
         return this;
@@ -109,7 +283,7 @@ export class Builder {
         return this.offset((page - 1) * perPage).limit(perPage);
     }
     join(table, first, operator, second, type = "INNER") {
-        const joinSql = `${type} JOIN ${this.wrap(table)} ON ${this.wrap(first)} ${operator} ${this.wrap(second)}`;
+        const joinSql = `${type} JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`;
         this.joins.push(joinSql);
         return this;
     }
@@ -119,6 +293,18 @@ export class Builder {
     rightJoin(table, first, operator, second) {
         return this.join(table, first, operator, second, "RIGHT");
     }
+    crossJoin(table) {
+        this.joins.push(`CROSS JOIN ${this.grammar.wrap(table)}`);
+        return this;
+    }
+    union(query, all = false) {
+        const sql = typeof query === "string" ? query : query.toSql();
+        this.unions.push({ query: sql, all });
+        return this;
+    }
+    unionAll(query) {
+        return this.union(query, true);
+    }
     with(...relations) {
         this.eagerLoads.push(...relations);
         return this;
@@ -154,6 +340,24 @@ export class Builder {
         const result = scope.call(this.model, this, ...args);
         return (result || this);
     }
+    when(condition, callback, defaultCallback) {
+        if (condition) {
+            const result = callback(this);
+            return (result || this);
+        }
+        else if (defaultCallback) {
+            const result = defaultCallback(this);
+            return (result || this);
+        }
+        return this;
+    }
+    unless(condition, callback, defaultCallback) {
+        return this.when(!condition, callback, defaultCallback);
+    }
+    tap(callback) {
+        const result = callback(this);
+        return (result || this);
+    }
     has(relationName, operator = ">=", count = 1, callback) {
         if (typeof operator === "function") {
             callback = operator;
@@ -167,7 +371,7 @@ export class Builder {
         if ((operator === "<" || operator === "=") && count <= 0) {
             return this.whereExists(relation.getRelationExistenceSql(this, callback), "and", true);
         }
-        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.escape(count)}`);
+        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.grammar.escape(count)}`);
     }
     orHas(relationName, operator = ">=", count = 1, callback) {
         if (typeof operator === "function") {
@@ -182,7 +386,7 @@ export class Builder {
         if ((operator === "<" || operator === "=") && count <= 0) {
             return this.whereExists(relation.getRelationExistenceSql(this, callback), "or", true);
         }
-        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.escape(count)}`, "or");
+        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.grammar.escape(count)}`, "or");
     }
     whereHas(relationName, callback, operator = ">=", count = 1) {
         return this.has(relationName, operator, count, callback);
@@ -220,6 +424,19 @@ export class Builder {
         this.columns.push(...columns);
         return this;
     }
+    selectRaw(sql) {
+        this.columns.push(sql);
+        return this;
+    }
+    fromSub(query, as) {
+        const sql = typeof query === "string" ? query : query.toSql();
+        this.fromRaw = `(${sql}) AS ${this.grammar.wrap(as)}`;
+        return this;
+    }
+    updateFrom(table, first, operator, second) {
+        this.updateJoins.push(`INNER JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`);
+        return this;
+    }
     clone() {
         const cloned = new Builder(this.connection, this.tableName);
         cloned.columns = [...this.columns];
@@ -233,89 +450,85 @@ export class Builder {
         cloned.distinctFlag = this.distinctFlag;
         cloned.model = this.model;
         cloned.eagerLoads = [...this.eagerLoads];
+        cloned.randomOrderFlag = this.randomOrderFlag;
+        cloned.lockMode = this.lockMode;
+        cloned.unions = [...this.unions];
+        cloned.fromRaw = this.fromRaw;
+        cloned.updateJoins = [...this.updateJoins];
         return cloned;
     }
     wrapColumn(value) {
-        return this.wrap(value);
+        return this.grammar.wrap(value);
     }
     escapeValue(value) {
-        return this.escape(value);
+        return this.grammar.escape(value);
     }
-    wrap(value) {
-        if (value.includes(" as ")) {
-            const [column, alias] = value.split(/\s+as\s+/i);
-            return `${this.wrap(column)} AS ${this.wrapValue(alias)}`;
+    compileWhereClause(where, prefix) {
+        if (where.type === "basic") {
+            return `${prefix} ${this.grammar.wrap(where.column)} ${where.operator} ${this.grammar.escape(where.value)}`;
         }
-        if (value.includes(".")) {
-            return value.split(".").map((v) => this.wrapValue(v)).join(".");
+        else if (where.type === "in") {
+            const op = where.operator === "NOT IN" ? "NOT IN" : "IN";
+            return `${prefix} ${this.grammar.wrap(where.column)} ${op} (${where.value.map((v) => this.grammar.escape(v)).join(", ")})`;
         }
-        return this.wrapValue(value);
-    }
-    wrapValue(value) {
-        const driver = this.connection.getDriverName();
-        const char = driver === "mysql" ? "`" : '"';
-        if (value === "*")
-            return value;
-        return `${char}${value}${char}`;
-    }
-    escape(value) {
-        if (value === null)
-            return "NULL";
-        if (typeof value === "boolean")
-            return value ? "1" : "0";
-        if (typeof value === "number")
-            return String(value);
-        if (typeof value === "string" && value.toUpperCase().includes("CURRENT_TIMESTAMP"))
-            return value;
-        return `'${String(value).replace(/'/g, "''")}'`;
+        else if (where.type === "null") {
+            const op = where.operator === "NOT NULL" ? "IS NOT NULL" : "IS NULL";
+            return `${prefix} ${this.grammar.wrap(where.column)} ${op}`;
+        }
+        else if (where.type === "between") {
+            const op = where.operator === "NOT BETWEEN" ? "NOT BETWEEN" : "BETWEEN";
+            return `${prefix} ${this.grammar.wrap(where.column)} ${op} ${this.grammar.escape(where.value[0])} AND ${this.grammar.escape(where.value[1])}`;
+        }
+        else if (where.type === "raw") {
+            return `${prefix} ${where.column}`;
+        }
+        else if (where.type === "column") {
+            return `${prefix} ${this.grammar.wrap(where.column)} ${where.operator} ${this.grammar.wrap(where.value)}`;
+        }
+        else if (where.type === "exists") {
+            return `${prefix} ${where.operator} (${where.column})`;
+        }
+        return "";
     }
     compileWheres() {
         if (this.wheres.length === 0)
             return "";
         const clauses = this.wheres.map((where, index) => {
             const prefix = index === 0 ? "WHERE" : where.boolean.toUpperCase();
-            if (where.type === "basic") {
-                return `${prefix} ${this.wrap(where.column)} ${where.operator} ${this.escape(where.value)}`;
-            }
-            else if (where.type === "in") {
-                const op = where.operator === "NOT IN" ? "NOT IN" : "IN";
-                return `${prefix} ${this.wrap(where.column)} ${op} (${where.value.map((v) => this.escape(v)).join(", ")})`;
-            }
-            else if (where.type === "null") {
-                const op = where.operator === "NOT NULL" ? "IS NOT NULL" : "IS NULL";
-                return `${prefix} ${this.wrap(where.column)} ${op}`;
-            }
-            else if (where.type === "between") {
-                const op = where.operator === "NOT BETWEEN" ? "NOT BETWEEN" : "BETWEEN";
-                return `${prefix} ${this.wrap(where.column)} ${op} ${this.escape(where.value[0])} AND ${this.escape(where.value[1])}`;
-            }
-            else if (where.type === "raw") {
-                return `${prefix} ${where.column}`;
-            }
-            else if (where.type === "column") {
-                return `${prefix} ${this.wrap(where.column)} ${where.operator} ${this.wrap(where.value)}`;
-            }
-            else if (where.type === "exists") {
-                return `${prefix} ${where.operator} (${where.column})`;
-            }
-            return "";
+            return this.compileWhereClause(where, prefix);
         });
         return clauses.join(" ");
     }
+    compileNestedWheres(builder) {
+        if (builder.wheres.length === 0)
+            return "";
+        const clauses = builder.wheres.map((where, index) => {
+            const prefix = index === 0 ? "" : where.boolean.toUpperCase();
+            return this.compileWhereClause(where, prefix);
+        });
+        return clauses.join(" ").trim();
+    }
     compileOrders() {
+        if (this.randomOrderFlag) {
+            return this.grammar.compileRandomOrder();
+        }
         if (this.orders.length === 0)
             return "";
-        return `ORDER BY ${this.orders.map((o) => `${this.wrap(o.column)} ${o.direction.toUpperCase()}`).join(", ")}`;
+        return `ORDER BY ${this.orders.map((o) => `${this.grammar.wrap(o.column)} ${o.direction.toUpperCase()}`).join(", ")}`;
     }
     compileGroups() {
         if (this.groups.length === 0)
             return "";
-        return `GROUP BY ${this.groups.map((c) => this.wrap(c)).join(", ")}`;
+        return `GROUP BY ${this.groups.map((c) => this.grammar.wrap(c)).join(", ")}`;
     }
     compileHavings() {
         if (this.havings.length === 0)
             return "";
-        return `HAVING ${this.havings.join(" AND ")}`;
+        const clauses = this.havings.map((h, index) => {
+            const prefix = index === 0 ? "" : h.boolean.toUpperCase() + " ";
+            return prefix + h.sql;
+        });
+        return `HAVING ${clauses.join(" ")}`;
     }
     compileLimit() {
         if (this.limitValue === undefined)
@@ -325,17 +538,18 @@ export class Builder {
     compileOffset() {
         if (this.offsetValue === undefined)
             return "";
-        return `OFFSET ${this.offsetValue}`;
+        return this.grammar.compileOffset(this.offsetValue, this.limitValue);
     }
     compileColumns() {
-        return this.columns.map((c) => (this.isRawColumn(c) ? c : this.wrap(c))).join(", ");
+        return this.columns.map((c) => (this.isRawColumn(c) ? c : this.grammar.wrap(c))).join(", ");
     }
     isRawColumn(column) {
         return column.includes("(") || /\s+as\s+/i.test(column) || /^[0-9]+$/.test(column);
     }
     toSql() {
         const distinct = this.distinctFlag ? "DISTINCT " : "";
-        let sql = `SELECT ${distinct}${this.compileColumns()} FROM ${this.wrap(this.tableName)}`;
+        const from = this.fromRaw || this.grammar.wrap(this.tableName);
+        let sql = `SELECT ${distinct}${this.compileColumns()} FROM ${from}`;
         if (this.joins.length > 0)
             sql += " " + this.joins.join(" ");
         sql += " " + this.compileWheres();
@@ -344,6 +558,10 @@ export class Builder {
         sql += " " + this.compileOrders();
         sql += " " + this.compileLimit();
         sql += " " + this.compileOffset();
+        sql += this.grammar.compileLock(this.lockMode);
+        for (const union of this.unions) {
+            sql += ` UNION${union.all ? " ALL" : ""} ${union.query}`;
+        }
         return sql.replace(/\s+/g, " ").trim();
     }
     async get() {
@@ -354,6 +572,9 @@ export class Builder {
                 const instance = new this.model(row);
                 instance.$exists = true;
                 instance.$original = { ...row };
+                if (typeof instance.setConnection === "function") {
+                    instance.setConnection(this.connection);
+                }
                 return instance;
             });
             if (this.eagerLoads.length > 0) {
@@ -370,6 +591,54 @@ export class Builder {
     async find(id, column = "id") {
         return this.where(column, id).first();
     }
+    async findOrFail(id, column = "id") {
+        const result = await this.find(id, column);
+        if (!result) {
+            throw new ModelNotFoundError(this.model?.name || "Model", id);
+        }
+        return result;
+    }
+    async firstOrFail() {
+        const result = await this.first();
+        if (!result) {
+            throw new ModelNotFoundError(this.model?.name || "Model");
+        }
+        return result;
+    }
+    async firstOrCreate(attributes = {}, values = {}) {
+        const found = await this.clone().where(attributes).first();
+        if (found)
+            return found;
+        if (!this.model) {
+            throw new Error("firstOrCreate requires a model to be set on the builder");
+        }
+        const instance = new this.model({ ...attributes, ...values });
+        if (typeof instance.setConnection === "function") {
+            instance.setConnection(this.connection);
+        }
+        await instance.save();
+        return instance;
+    }
+    async updateOrCreate(attributes, values = {}) {
+        const found = await this.clone().where(attributes).first();
+        if (found) {
+            const model = found;
+            if (typeof model.fill === "function") {
+                model.fill(values);
+                await model.save();
+            }
+            return found;
+        }
+        if (!this.model) {
+            throw new Error("updateOrCreate requires a model to be set on the builder");
+        }
+        const instance = new this.model({ ...attributes, ...values });
+        if (typeof instance.setConnection === "function") {
+            instance.setConnection(this.connection);
+        }
+        await instance.save();
+        return instance;
+    }
     async pluck(column) {
         const results = await this.select(column).get();
         return results.map((row) => row[column]);
@@ -409,32 +678,110 @@ export class Builder {
             to: total === 0 ? 0 : Math.min(page * perPage, total),
         };
     }
+    async chunk(count, callback) {
+        let page = 1;
+        while (true) {
+            const items = await this.clone().forPage(page, count).get();
+            if (items.length === 0)
+                break;
+            await callback(items);
+            if (items.length < count)
+                break;
+            page++;
+        }
+    }
+    async each(count, callback) {
+        await this.chunk(count, async (items) => {
+            for (const item of items) {
+                await callback(item);
+            }
+        });
+    }
+    async *cursor() {
+        let offset = 0;
+        while (true) {
+            const items = await this.clone().offset(offset).limit(1).get();
+            if (items.length === 0)
+                break;
+            yield items[0];
+            offset++;
+        }
+    }
+    async *lazy(count = 1000) {
+        let page = 1;
+        while (true) {
+            const items = await this.clone().forPage(page, count).get();
+            if (items.length === 0)
+                break;
+            for (const item of items) {
+                yield item;
+            }
+            if (items.length < count)
+                break;
+            page++;
+        }
+    }
     async insert(data) {
         const records = Array.isArray(data) ? data : [data];
         if (records.length === 0)
             return;
         const columns = Object.keys(records[0]);
         const values = records.map((record) => {
-            return `(${columns.map((col) => this.escape(record[col])).join(", ")})`;
+            return `(${columns.map((col) => this.grammar.escape(record[col])).join(", ")})`;
         });
-        const sql = `INSERT INTO ${this.wrap(this.tableName)} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")}`;
+        const sql = `INSERT INTO ${this.grammar.wrap(this.tableName)} (${columns.map((c) => this.grammar.wrap(c)).join(", ")}) VALUES ${values.join(", ")}`;
         return await this.connection.run(sql);
     }
     async insertGetId(data, idColumn = "id") {
         const result = await this.insert(data);
         return result?.lastInsertRowid ?? result?.insertId ?? null;
     }
+    async insertOrIgnore(data) {
+        const records = Array.isArray(data) ? data : [data];
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]);
+        const values = records.map((record) => {
+            return `(${columns.map((col) => this.grammar.escape(record[col])).join(", ")})`;
+        });
+        const sql = this.grammar.compileInsertOrIgnore(this.grammar.wrap(this.tableName), columns, values);
+        return await this.connection.run(sql);
+    }
+    async upsert(data, uniqueBy, updateColumns) {
+        const records = Array.isArray(data) ? data : [data];
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]);
+        const values = records.map((record) => {
+            return `(${columns.map((col) => this.grammar.escape(record[col])).join(", ")})`;
+        });
+        const uniqueCols = Array.isArray(uniqueBy) ? uniqueBy : [uniqueBy];
+        const updateCols = updateColumns ?? columns.filter((c) => !uniqueCols.includes(c));
+        const sql = this.grammar.compileUpsert(this.grammar.wrap(this.tableName), columns, values, uniqueCols, updateCols);
+        return await this.connection.run(sql);
+    }
     async update(data) {
         const sets = Object.entries(data)
-            .map(([key, value]) => `${this.wrap(key)} = ${this.escape(value)}`)
+            .map(([key, value]) => `${this.grammar.wrap(key)} = ${this.grammar.escape(value)}`)
             .join(", ");
-        const sql = `UPDATE ${this.wrap(this.tableName)} SET ${sets} ${this.compileWheres()}`;
-        return await this.connection.run(sql.trim());
+        const sql = this.grammar.compileUpdate(this.grammar.wrap(this.tableName), sets.split(", "), this.compileWheres(), this.updateJoins);
+        return await this.connection.run(sql);
     }
     async delete() {
-        const sql = `DELETE FROM ${this.wrap(this.tableName)} ${this.compileWheres()}`;
+        const sql = this.grammar.compileDelete(this.grammar.wrap(this.tableName), this.compileWheres(), this.updateJoins, this.limitValue);
+        return await this.connection.run(sql);
+    }
+    async increment(column, amount = 1, extra = {}) {
+        const sets = [`${this.grammar.wrap(column)} = ${this.grammar.wrap(column)} + ${amount}`];
+        for (const [key, value] of Object.entries(extra)) {
+            sets.push(`${this.grammar.wrap(key)} = ${this.grammar.escape(value)}`);
+        }
+        const sql = `UPDATE ${this.grammar.wrap(this.tableName)} SET ${sets.join(", ")} ${this.compileWheres()}`;
         return await this.connection.run(sql.trim());
     }
+    async decrement(column, amount = 1, extra = {}) {
+        return this.increment(column, -amount, extra);
+    }
     async restore() {
         const model = this.model;
         if (!model?.softDeletes) {
@@ -446,6 +793,80 @@ export class Builder {
         const result = await this.select("1 as exists_check").limit(1).get();
         return result.length > 0;
     }
+    async doesntExist() {
+        return !(await this.exists());
+    }
+    async sole() {
+        const results = await this.limit(2).get();
+        if (results.length === 0) {
+            throw new ModelNotFoundError(this.model?.name || "Model");
+        }
+        if (results.length > 1) {
+            throw new Error("Multiple records found when only one was expected.");
+        }
+        return results[0];
+    }
+    async value(column) {
+        const result = await this.first();
+        return result ? result[column] : null;
+    }
+    dump() {
+        console.log(this.toSql());
+        return this;
+    }
+    dd() {
+        console.log(this.toSql());
+        throw new Error("dd() called — execution halted.");
+    }
+    async explain() {
+        const sql = this.grammar.compileExplain(this.toSql());
+        const results = await this.connection.query(sql);
+        return Array.from(results);
+    }
+    take(count) {
+        return this.limit(count);
+    }
+    skip(count) {
+        return this.offset(count);
+    }
+    lockForUpdate() {
+        const driver = this.connection.getDriverName();
+        if (driver !== "sqlite") {
+            this.lockMode = "FOR UPDATE";
+        }
+        return this;
+    }
+    sharedLock() {
+        const driver = this.connection.getDriverName();
+        if (driver === "mysql") {
+            this.lockMode = "LOCK IN SHARE MODE";
+        }
+        else if (driver === "postgres") {
+            this.lockMode = "FOR SHARE";
+        }
+        return this;
+    }
+    skipLocked() {
+        if (this.lockMode) {
+            this.lockMode += " SKIP LOCKED";
+        }
+        return this;
+    }
+    noWait() {
+        if (this.lockMode) {
+            this.lockMode += " NOWAIT";
+        }
+        return this;
+    }
+    addDateWhere(type, column, operator, value, boolean = "and") {
+        if (value === undefined) {
+            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 });
+        return this;
+    }
     getModelRelation(relationName) {
         if (!this.model) {
             throw new Error(`Cannot query relation "${relationName}" without a model`);