@bunnykit/orm 0.1.5 → 0.1.6

package/dist/src/query/Builder.js

@@ -15,10 +15,16 @@ export class Builder {
     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;
@@ -142,6 +148,85 @@ 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;
@@ -156,14 +241,36 @@ export class Builder {
         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;
@@ -176,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;
     }
@@ -186,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;
@@ -252,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") {
@@ -267,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);
@@ -305,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];
@@ -320,63 +452,38 @@ export class Builder {
         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);
-    }
-    wrap(value) {
-        if (value.includes(" as ")) {
-            const [column, alias] = value.split(/\s+as\s+/i);
-            return `${this.wrap(column)} AS ${this.wrapValue(alias)}`;
-        }
-        if (value.includes(".")) {
-            return value.split(".").map((v) => this.wrapValue(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, "''")}'`;
+        return this.grammar.escape(value);
     }
     compileWhereClause(where, prefix) {
         if (where.type === "basic") {
-            return `${prefix} ${this.wrap(where.column)} ${where.operator} ${this.escape(where.value)}`;
+            return `${prefix} ${this.grammar.wrap(where.column)} ${where.operator} ${this.grammar.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(", ")})`;
+            return `${prefix} ${this.grammar.wrap(where.column)} ${op} (${where.value.map((v) => this.grammar.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}`;
+            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.wrap(where.column)} ${op} ${this.escape(where.value[0])} AND ${this.escape(where.value[1])}`;
+            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.wrap(where.column)} ${where.operator} ${this.wrap(where.value)}`;
+            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})`;
@@ -403,23 +510,25 @@ export class Builder {
     }
     compileOrders() {
         if (this.randomOrderFlag) {
-            const driver = this.connection.getDriverName();
-            const fn = driver === "mysql" ? "RAND()" : "RANDOM()";
-            return `ORDER BY ${fn}`;
+            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)
@@ -429,20 +538,18 @@ export class Builder {
     compileOffset() {
         if (this.offsetValue === undefined)
             return "";
-        const limitSql = this.limitValue === undefined && this.connection.getDriverName() === "sqlite"
-            ? "LIMIT -1 "
-            : "";
-        return `${limitSql}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();
@@ -451,8 +558,10 @@ export class Builder {
         sql += " " + this.compileOrders();
         sql += " " + this.compileLimit();
         sql += " " + this.compileOffset();
-        if (this.lockMode)
-            sql += " " + this.lockMode;
+        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() {
@@ -463,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) {
@@ -500,7 +612,12 @@ export class Builder {
         if (!this.model) {
             throw new Error("firstOrCreate requires a model to be set on the builder");
         }
-        return this.model.create({ ...attributes, ...values });
+        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();
@@ -515,7 +632,12 @@ export class Builder {
         if (!this.model) {
             throw new Error("updateOrCreate requires a model to be set on the builder");
         }
-        return this.model.create({ ...attributes, ...values });
+        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();
@@ -605,32 +727,56 @@ export class Builder {
             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()}`;
-        return await this.connection.run(sql.trim());
+        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.wrap(column)} = ${this.wrap(column)} + ${amount}`];
+        const sets = [`${this.grammar.wrap(column)} = ${this.grammar.wrap(column)} + ${amount}`];
         for (const [key, value] of Object.entries(extra)) {
-            sets.push(`${this.wrap(key)} = ${this.escape(value)}`);
+            sets.push(`${this.grammar.wrap(key)} = ${this.grammar.escape(value)}`);
         }
-        const sql = `UPDATE ${this.wrap(this.tableName)} SET ${sets.join(", ")} ${this.compileWheres()}`;
+        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 = {}) {
@@ -650,6 +796,33 @@ export class Builder {
     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);
     }
@@ -659,7 +832,7 @@ export class Builder {
     lockForUpdate() {
         const driver = this.connection.getDriverName();
         if (driver !== "sqlite") {
-            this.lockMode = driver === "mysql" ? "FOR UPDATE" : "FOR UPDATE";
+            this.lockMode = "FOR UPDATE";
         }
         return this;
     }
@@ -673,58 +846,24 @@ export class Builder {
         }
         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 driver = this.connection.getDriverName();
-        const wrapped = this.wrap(column);
-        let sql;
-        switch (type) {
-            case "date":
-                if (driver === "sqlite")
-                    sql = `date(${wrapped}) ${operator} ${this.escape(value)}`;
-                else if (driver === "mysql")
-                    sql = `DATE(${wrapped}) ${operator} ${this.escape(value)}`;
-                else
-                    sql = `(${wrapped})::date ${operator} ${this.escape(value)}`;
-                break;
-            case "day":
-                if (driver === "sqlite")
-                    sql = `CAST(strftime('%d', ${wrapped}) AS INTEGER) ${operator} ${this.escape(value)}`;
-                else if (driver === "mysql")
-                    sql = `DAY(${wrapped}) ${operator} ${this.escape(value)}`;
-                else
-                    sql = `EXTRACT(DAY FROM ${wrapped}) ${operator} ${this.escape(value)}`;
-                break;
-            case "month":
-                if (driver === "sqlite")
-                    sql = `CAST(strftime('%m', ${wrapped}) AS INTEGER) ${operator} ${this.escape(value)}`;
-                else if (driver === "mysql")
-                    sql = `MONTH(${wrapped}) ${operator} ${this.escape(value)}`;
-                else
-                    sql = `EXTRACT(MONTH FROM ${wrapped}) ${operator} ${this.escape(value)}`;
-                break;
-            case "year":
-                if (driver === "sqlite")
-                    sql = `CAST(strftime('%Y', ${wrapped}) AS INTEGER) ${operator} ${this.escape(value)}`;
-                else if (driver === "mysql")
-                    sql = `YEAR(${wrapped}) ${operator} ${this.escape(value)}`;
-                else
-                    sql = `EXTRACT(YEAR FROM ${wrapped}) ${operator} ${this.escape(value)}`;
-                break;
-            case "time":
-                if (driver === "sqlite")
-                    sql = `time(${wrapped}) ${operator} ${this.escape(value)}`;
-                else if (driver === "mysql")
-                    sql = `TIME(${wrapped}) ${operator} ${this.escape(value)}`;
-                else
-                    sql = `(${wrapped})::time ${operator} ${this.escape(value)}`;
-                break;
-            default:
-                sql = `${wrapped} ${operator} ${this.escape(value)}`;
-        }
+        const sql = this.grammar.compileDateWhere(type, this.grammar.wrap(column), operator, value);
         this.wheres.push({ type: "raw", column: sql, boolean, scope: undefined });
         return this;
     }

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

@@ -0,0 +1,19 @@
+export declare abstract class Grammar {
+    abstract wrap(value: string): string;
+    wrapArray(values: string[]): string[];
+    escape(value: any): string;
+    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 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 compileExplain(sql: string): string;
+}

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

@@ -0,0 +1,47 @@
+export class Grammar {
+    wrapArray(values) {
+        return values.map((v) => this.wrap(v));
+    }
+    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, "''")}'`;
+    }
+    compileOffset(offset, _limit) {
+        return `OFFSET ${offset}`;
+    }
+    compileLock(lockMode) {
+        return lockMode ? ` ${lockMode}` : "";
+    }
+    compileUpdate(table, sets, wheres, joins) {
+        let sql = `UPDATE ${table}`;
+        if (joins && joins.length > 0) {
+            sql += ` ${joins.join(" ")}`;
+        }
+        sql += ` SET ${sets.join(", ")}`;
+        if (wheres)
+            sql += ` ${wheres}`;
+        return sql.trim();
+    }
+    compileDelete(table, wheres, joins, limit) {
+        let sql = `DELETE FROM ${table}`;
+        if (joins && joins.length > 0) {
+            sql += ` ${joins.join(" ")}`;
+        }
+        if (wheres)
+            sql += ` ${wheres}`;
+        if (limit !== undefined)
+            sql += ` LIMIT ${limit}`;
+        return sql.trim();
+    }
+    compileLike(column, value, not) {
+        const op = not ? "NOT LIKE" : "LIKE";
+        return `${column} ${op} ${this.escape(value)}`;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Grammar } from "./Grammar.js";
+export declare class MySqlGrammar extends Grammar {
+    wrap(value: string): string;
+    compileRandomOrder(): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any): 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;
+    compileExplain(sql: string): string;
+}