jcc-express-mvc 1.7.2 → 1.7.3

package/lib/Jcc-eloquent/lib/Builder.js

@@ -4,748 +4,773 @@ exports.Builder = void 0;
 const Database_1 = require("./Database");
 const utils_1 = require("./utils");
 class Builder {
-    constructor() {
-        this.tableName = "";
-        this.queryBuilder = null;
-        this.model = null;
-        this.eagerLoad = [];
-        this.softDelete = true; // Default to true (filtering out deleted), set to false to include deleted
-        this.db = Database_1.Database.connect();
-    }
-    withTrashed() {
-        this.softDelete = false;
-        return this;
-    }
-    onlyTrashed() {
-        this.softDelete = false;
-        this.whereNotNull("deleted_at");
-        return this;
-    }
-    with(relations) {
-        if (typeof relations === "string") {
-            this.eagerLoad = [relations];
-        }
-        else {
-            this.eagerLoad = relations;
-        }
-        return this;
-    }
-    setModel(model) {
-        this.model = model;
-        return this;
-    }
-    has(relation, operator = ">=", count = 1, boolean = "and", callback) {
-        if (!this.model) {
-            throw new Error("Model not set for builder");
-        }
-        const instance = new this.model();
-        const relationObject = instance[relation]();
-        const query = relationObject.getRelationExistenceQuery(relationObject.getQuery(), this.getQueryBuilder());
-        if (callback) {
-            callback(query);
-        }
-        const { sql, bindings } = query.toSQL();
-        if (operator === ">=" && count === 1) {
-            const method = boolean === "or" ? "orWhereRaw" : "whereRaw";
-            this[method](`exists (${sql})`, bindings);
-        }
-        else {
-            query.clearSelect().count("*");
-            const { sql: countSql, bindings: countBindings } = query.toSQL();
-            const method = boolean === "or" ? "orWhereRaw" : "whereRaw";
-            this[method](`(${countSql}) ${operator} ?`, [
-                ...countBindings,
-                count,
-            ]);
-        }
-        return this;
-    }
-    whereHas(relation, callback, operator = ">=", count = 1) {
-        return this.has(relation, operator, count, "and", callback);
-    }
-    orWhereHas(relation, callback, operator = ">=", count = 1) {
-        return this.has(relation, operator, count, "or", callback);
-    }
-    getQueryBuilder() {
-        if (!this.queryBuilder) {
-            this.queryBuilder = this.db.queryBuilder().from(this.tableName);
-        }
-        return this.queryBuilder;
-    }
-    /**
-     * Set the table for the query and reset the queryBuilder
-     */
-    from(tableName) {
-        this.tableName = tableName;
-        this.queryBuilder = this.db.queryBuilder().from(this.tableName);
-        return this;
-    }
-    /**
-     *
-     * @param columnName
-     * @returns
-     */
-    as(columnName) {
-        this.getQueryBuilder().as(columnName);
-        return this;
-    }
-    fromRaw(query) {
-        this.queryBuilder?.fromRaw(query);
-        return this;
-    }
-    /**
-     * Alias for from()
-     */
-    table(tableName) {
-        return this.from(tableName);
-    }
-    /**
-     * Select specific columns for the query.
-     * @param
-     */
-    select(...columns) {
-        this.queryBuilder = this.getQueryBuilder().select(columns.length ? columns : "*");
-        return this;
-    }
-    whereJson(path, operator, value) {
-        const [jsonColumn, ...pathParts] = path.split(".");
-        const jsonPath = `$.${pathParts.join(".")}`;
-        if (!value) {
-            this.getQueryBuilder().whereRaw(`JSON_UNQUOTE(JSON_EXTRACT(??, ?)) = ?`, [
-                jsonColumn,
-                jsonPath,
-                operator,
-            ]);
-        }
-        else {
-            this.getQueryBuilder().whereRaw(`JSON_UNQUOTE(JSON_EXTRACT(??, ?)) ${operator} ?`, [jsonColumn, jsonPath, operator]);
-        }
-        return this;
-    }
-    /**
-     * Add a where clause to the query - Laravel style
-     *
-     * Supports multiple signatures:
-     * 1. where(callback) - Grouped conditions
-     * 2. where([...conditions]) - Array of conditions
-     * 3. where({key: value}) - Object syntax
-     * 4. where(column, value) - Two-argument form (assumes = operator)
-     * 5. where(column, operator, value) - Three-argument form
-     *
-     * @example
-     * // Closure for grouped conditions
-     * query.where((q) => {
-     *   q.where('age', '>', 18).orWhere('vip', true);
-     * });
-     *
-     * // Array of conditions
-     * query.where([
-     *   ['status', 'active'],
-     *   ['role', '=', 'admin']
-     * ]);
-     *
-     * // Object syntax
-     * query.where({ status: 'active', role: 'admin' });
-     *
-     * // Two-argument form
-     * query.where('status', 'active');
-     *
-     * // Three-argument form
-     * query.where('age', '>', 18);
-     */
-    where(column, operator, value) {
-        if (typeof column === "function") {
-            this.getQueryBuilder().where((qb) => {
-                const subQuery = new this.constructor();
-                subQuery.queryBuilder = qb;
-                column(subQuery);
-            });
-            return this;
-        }
-        if (Array.isArray(column)) {
-            column.forEach((condition) => {
-                if (condition.length === 2) {
-                    this.where(condition[0], "=", condition[1]);
-                }
-                else if (condition.length === 3) {
-                    this.where(condition[0], condition[1], condition[2]);
-                }
-            });
-            return this;
-        }
-        if (typeof column === "object" &&
-            column !== null &&
-            !Array.isArray(column)) {
-            Object.entries(column).forEach(([key, val]) => {
-                this.where(key, "=", val);
-            });
-            return this;
-        }
-        // Case 4 & 5: String column name
-        const isJson = column.includes(".") && !column.includes(" ");
-        // Two-argument form: where(column, value)
-        if (value === undefined && operator !== undefined && !isJson) {
-            this.getQueryBuilder().where(column, "=", operator);
-            return this;
-        }
-        // JSON path handling
-        if (isJson) {
-            this.whereJson(column, operator, value || "");
-            return this;
-        }
-        // Three-argument form: where(column, operator, value)
-        this.getQueryBuilder().where(column, operator, value || "");
-        return this;
-    }
-    whereNull(column) {
-        this.getQueryBuilder().whereNull(column);
-        return this;
-    }
-    whereNot(column, operator, value) {
-        if (value === undefined) {
-            this.getQueryBuilder().whereNot(column, operator);
-        }
-        else {
-            this.getQueryBuilder().whereNot(column, operator, value);
-        }
-        return this;
-    }
-    orWhereNot(column, operator, value) {
-        if (value === undefined) {
-            this.getQueryBuilder().orWhereNot(column, operator);
-        }
-        else {
-            this.getQueryBuilder().orWhereNot(column, operator, value);
-        }
-        return this;
-    }
-    whereNotNull(column) {
-        this.getQueryBuilder().whereNotNull(column);
-        return this;
-    }
-    whereExists(callback) {
-        return this.applyExists("whereRaw", callback);
-    }
-    orWhereExists(callback) {
-        return this.applyExists("orWhereRaw", callback);
-    }
-    whereBetween(column, range) {
-        this.getQueryBuilder().whereBetween(column, range);
-        return this;
-    }
-    orWhereBetween(column, range) {
-        this.getQueryBuilder().orWhereBetween(column, range);
-        return this;
-    }
-    whereNotBetween(column, range) {
-        this.getQueryBuilder().whereNotBetween(column, range);
-        return this;
-    }
-    orWhereNotBetween(column, range) {
-        this.getQueryBuilder().orWhereNotBetween(column, range);
-        return this;
-    }
-    orderBy(column, direction = "asc") {
-        this.getQueryBuilder().orderBy(column, direction);
-        return this;
-    }
-    orderByRaw(query, bindings) {
-        this.getQueryBuilder().orderByRaw(query, bindings);
-        return this;
-    }
-    latest(column = "id") {
-        this.getQueryBuilder().orderBy(column, "desc");
-        return this;
-    }
-    older(column = "id") {
-        this.getQueryBuilder().orderBy(column, "asc");
-        return this;
-    }
-    having(column, operator, value) {
-        if (!value) {
-            this.getQueryBuilder().having(column, "=", operator);
-        }
-        else {
-            this.getQueryBuilder().having(column, operator, value);
-        }
-        return this;
-    }
-    havingIn(column, values) {
-        this.getQueryBuilder().havingIn(column, values);
-        return this;
-    }
-    havingNotIn(column, values) {
-        this.getQueryBuilder().havingIn(column, values);
-        return this;
-    }
-    havingNull(column) {
-        this.getQueryBuilder().havingNull(column);
-        return this;
-    }
-    havingNotNull(column) {
-        this.getQueryBuilder().havingNotNull(column);
-        return this;
-    }
-    havingBetween(column, values) {
-        this.getQueryBuilder().havingBetween(column, values);
-        return this;
-    }
-    havingNotBetween(column, values) {
-        this.getQueryBuilder().havingNotBetween(column, values);
-        return this;
-    }
-    havingRaw(column, values) {
-        this.getQueryBuilder().havingRaw(column, values);
-        return this;
-    }
-    orWhere(column, operator, value) {
-        if (value === undefined) {
-            this.getQueryBuilder().orWhere(column, operator);
-        }
-        else {
-            this.getQueryBuilder().orWhere(column, operator, value);
-        }
-        return this;
-    }
-    whereIn(column, values) {
-        if (typeof values === "function") {
-            this.getQueryBuilder().whereIn(column, function () {
-                values(this);
-            });
-        }
-        else {
-            this.getQueryBuilder().whereIn(column, values);
-        }
-        return this;
-    }
-    whereLike(column, value) {
-        this.getQueryBuilder().whereLike(column, `%${value}%`);
-        return this;
-    }
-    andWhereLike(column, value) {
-        this.getQueryBuilder().andWhereLike(column, `%${value}%`);
-        return this;
-    }
-    orWhereLike(column, value) {
-        this.getQueryBuilder().orWhereLike(column, `%${value}%`);
-        return this;
-    }
-    joinRaw(sql, bindings) {
-        this.getQueryBuilder().joinRaw(sql, bindings);
-        return this;
-    }
-    join(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("join", table, columnOrCallback, operator, column2);
-    }
-    innerJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("innerJoin", table, columnOrCallback, operator, column2);
-    }
-    toSQL() {
-        return this.getQueryBuilder().toSQL();
-    }
-    joinSub(subQuery, alias, callback) {
-        return this._joinSubWithType("INNER", subQuery, alias, callback);
-    }
-    leftJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("leftJoin", table, columnOrCallback, operator, column2);
-    }
-    rightJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("rightJoin", table, columnOrCallback, operator, column2);
-    }
-    leftOuterJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("leftOuterJoin", table, columnOrCallback, operator, column2);
-    }
-    rightOuterJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("rightOuterJoin", table, columnOrCallback, operator, column2);
-    }
-    fullOuterJoin(table, columnOrCallback, operator, column2) {
-        return this.applyJoin("fullOuterJoin", table, columnOrCallback, operator, column2);
-    }
-    _joinSubWithType(type, subQuery, alias, callback) {
-        const { sql, bindings } = subQuery.toSQL();
-        const clauses = [];
-        const onBuilder = {
-            on(left, op, right) {
-                clauses.push(`${left} ${op} ${right}`);
-            },
-            onRaw(raw) {
-                clauses.push(raw);
-            },
-        };
-        callback(onBuilder);
-        const onClause = clauses.join(" ");
-        clauses.length = 0;
-        this.joinRaw(`${type} JOIN (${this.raw(sql, bindings)}) AS ${alias} ${onClause}`);
-        return this;
-    }
-    applyJoin(type, table, columnOrCallback, operator, column2) {
-        const qb = this.getQueryBuilder();
-        const self = this;
-        //
-        if (typeof columnOrCallback === "function") {
-            qb.join(table, function () {
-                columnOrCallback(self.applyJoinHelper(this));
-            });
-        }
-        else if (operator && column2) {
-            qb.join(table, columnOrCallback, operator, column2);
-        }
-        else {
-            throw new Error(`Invalid ${type} parameters`);
-        }
-        return this;
-    }
-    crossJoinSub(subQuery, alias) {
-        const { sql, bindings } = subQuery.toSQL();
-        this.joinRaw(`CROSS JOIN (${this.raw(sql, bindings)}) AS ${alias}`);
-        return this;
-    }
-    leftJoinSub(subQuery, alias, callback) {
-        return this._joinSubWithType("LEFT", subQuery, alias, callback);
-    }
-    rightJoinSub(subQuery, alias, callback) {
-        return this._joinSubWithType("RIGHT", subQuery, alias, callback);
-    }
-    clearSelect() {
-        this.getQueryBuilder().clearSelect();
-        return this;
-    }
-    clearGroup() {
-        this.getQueryBuilder().clearGroup();
-        return this;
-    }
-    clearHaving() {
-        this.getQueryBuilder().clearHaving();
-        return this;
-    }
-    clearWhere() {
-        this.getQueryBuilder().clearWhere();
-        return this;
-    }
-    distinct(...columns) {
-        this.getQueryBuilder().distinct(columns);
-        return this;
-    }
-    groupBy(...columns) {
-        this.getQueryBuilder().groupBy(columns);
-        return this;
-    }
-    groupByRaw(query, bindings) {
-        this.getQueryBuilder().groupByRaw(query, bindings);
-        return this;
-    }
-    async get() {
-        const result = this.getQueryBuilder().clone();
-        console.log(result.toSQL());
-        this.reset();
-        return result;
-    }
-    async first() {
-        const result = await this.limit(1).get();
-        this.reset();
-        return result.length ? result[0] : null;
-    }
-    clone() {
-        const clone = new Builder();
-        clone.queryBuilder = this.getQueryBuilder().clone();
-        clone.tableName = this.tableName;
-        clone.model = this.model;
-        clone.db = this.db;
-        clone.eagerLoad = [...this.eagerLoad];
-        clone.softDelete = this.softDelete;
-        return clone;
-    }
-    /**
-     * Check if any record exists for the current query.
-     */
-    async exists() {
-        const result = await this.first();
-        this.reset();
-        console.log({ result });
-        return !!result;
-    }
-    /**
-     * Check if no record exists for the current query.
-     */
-    async doesntExist() {
-        return !(await this.exists());
-    }
-    /**
-     * Get a single column's value from the first result.
-     */
-    async value(column) {
-        const row = await this.first();
-        return row ? row[column] : null;
-    }
-    async insert(data) {
-        const result = await this.db(this.tableName).insert(data);
-        this.reset();
-        return result && Array.isArray(result) ? result[0] : result;
-    }
-    async update(data) {
-        let result = false;
-        for (const key in data) {
-            if (key.includes(".")) {
-                result = await this.updateJson(key, data[key]);
-                delete data[key];
-            }
-        }
-        if (Object.keys(data).length > 0) {
-            result = await this.getQueryBuilder().update(data);
-        }
-        this.reset();
-        return result ? true : false;
-    }
-    async delete() {
-        const result = await this.getQueryBuilder().delete();
-        this.reset();
-        return result;
-    }
-    raw(query, bindings = []) {
-        return this.db.raw(query, bindings);
-    }
-    whereRaw(query, bindings = []) {
-        this.getQueryBuilder().whereRaw(query, bindings);
-        return this;
-    }
-    orWhereRaw(query, bindings = []) {
-        this.getQueryBuilder().orWhereRaw(query, bindings);
-        return this;
-    }
-    async runQuery(query, bindings = []) {
-        const res = await this.db.raw(query, bindings);
-        return res?.rows ? res?.rows : res;
-    }
-    returning(columns) {
-        this.getQueryBuilder().returning(columns);
-        return this;
-    }
-    offset(value) {
-        this.getQueryBuilder().offset(value);
-        return this;
-    }
-    limit(value) {
-        this.getQueryBuilder().limit(value);
-        return this;
-    }
-    union(queries) {
-        return this.applyUnion("union", queries);
-    }
-    unionAll(queries) {
-        return this.applyUnion("unionAll", queries);
-    }
-    toSqlCode() {
-        return this.queryBuilder.toSQL().sql;
-    }
-    max(columns) {
-        return this.applyAggregate("max", columns);
-    }
-    async count(columns = "id") {
-        this.applyAggregate("count", columns);
-        return utils_1.Utils.countValue(await this.first());
-    }
-    min(columns) {
-        return this.applyAggregate("min", columns);
-    }
-    sum(columns) {
-        return this.applyAggregate("sum", columns);
-    }
-    avg(columns) {
-        return this.applyAggregate("avg", columns);
-    }
-    increment(column, amount) {
-        if (typeof column === "string") {
-            this.queryBuilder.increment(column, amount ?? 1);
-        }
-        else {
-            this.queryBuilder.increment(column); // object form { col1: value1, col2: value2 }
-        }
-        return this;
-    }
-    truncate() {
-        this.queryBuilder.truncate();
-        return this;
-    }
-    async paginate(request, perPage = 15) {
-        const page = Math.max(1, Number(request.query.page) || 1);
-        const offset = (page - 1) * Number(perPage);
-        const count = await this.clone().count();
-        const total = count;
-        const data = await this.clone().offset(offset).limit(Number(perPage)).get();
-        const totalPages = Math.ceil(total / Number(perPage));
-        const path = `${request.protocol}://${request.get("host")}${request.path}`;
-        return {
-            data: data,
-            meta: {
-                current_page: page,
-                per_page: perPage,
-                total: total,
-                total_pages: totalPages,
-                has_more: page < totalPages,
-                links: utils_1.Utils.generatePaginationLinks(path, page, totalPages),
-            },
-            links: {
-                first: `${path}?page=1`,
-                last: `${path}?page=${totalPages}`,
-            },
-        };
-    }
-    plunk(column) {
-        this.getQueryBuilder().pluck(column);
-        return this;
-    }
-    /**
-     * Get an array of values for a single column (alias like Laravel pluck).
-     */
-    async pluck(column) {
-        const result = await this.queryBuilder.pluck(column);
-        this.reset();
-        return result;
-    }
-    decrement(column, amount) {
-        if (typeof column === "string") {
-            this.getQueryBuilder().decrement(column, amount ?? 1);
-        }
-        else {
-            this.getQueryBuilder().decrement(column); // object form
-        }
-        return this;
-    }
-    async updateJson(path, value) {
-        const [column, ...jsonPathParts] = path.split(".");
-        const jsonPath = "$." + jsonPathParts.join(".");
-        const result = await this.getQueryBuilder().update({
-            [column]: this.db.raw(`JSON_SET(??, ?, ?)`, [column, jsonPath, value]),
-        });
-        this.reset();
-        return result ? true : false;
-    }
-    applyJoinHelper(joinBuilder) {
-        const db = this.db; // or however you access knex
-        const helper = {
-            on: (c1, op, c2) => {
-                joinBuilder.on(c1, op, c2);
-                return helper;
-            },
-            orOn: (c1, op, c2) => {
-                joinBuilder.orOn(c1, op, c2);
-                return helper;
-            },
-            raw: (sql, bindings = []) => {
-                joinBuilder.on(db.raw(sql, bindings));
-                return helper;
-            },
-        };
+  constructor() {
+    this.tableName = "";
+    this.queryBuilder = null;
+    this.model = null;
+    this.eagerLoad = [];
+    this.softDelete = true; // Default to true (filtering out deleted), set to false to include deleted
+    this.db = Database_1.Database.connect();
+  }
+  withTrashed() {
+    this.softDelete = false;
+    return this;
+  }
+  onlyTrashed() {
+    this.softDelete = false;
+    this.whereNotNull("deleted_at");
+    return this;
+  }
+  with(relations) {
+    if (typeof relations === "string") {
+      this.eagerLoad = [relations];
+    } else {
+      this.eagerLoad = relations;
+    }
+    return this;
+  }
+  setModel(model) {
+    this.model = model;
+    return this;
+  }
+  has(relation, operator = ">=", count = 1, boolean = "and", callback) {
+    if (!this.model) {
+      throw new Error("Model not set for builder");
+    }
+    const instance = new this.model();
+    const relationObject = instance[relation]();
+    const query = relationObject.getRelationExistenceQuery(
+      relationObject.getQuery(),
+      this.getQueryBuilder()
+    );
+    if (callback) {
+      callback(query);
+    }
+    const { sql, bindings } = query.toSQL();
+    if (operator === ">=" && count === 1) {
+      const method = boolean === "or" ? "orWhereRaw" : "whereRaw";
+      this[method](`exists (${sql})`, bindings);
+    } else {
+      query.clearSelect().count("*");
+      const { sql: countSql, bindings: countBindings } = query.toSQL();
+      const method = boolean === "or" ? "orWhereRaw" : "whereRaw";
+      this[method](`(${countSql}) ${operator} ?`, [...countBindings, count]);
+    }
+    return this;
+  }
+  whereHas(relation, callback, operator = ">=", count = 1) {
+    return this.has(relation, operator, count, "and", callback);
+  }
+  orWhereHas(relation, callback, operator = ">=", count = 1) {
+    return this.has(relation, operator, count, "or", callback);
+  }
+  getQueryBuilder() {
+    if (!this.queryBuilder) {
+      this.queryBuilder = this.db.queryBuilder().from(this.tableName);
+    }
+    return this.queryBuilder;
+  }
+  /**
+   * Set the table for the query and reset the queryBuilder
+   */
+  from(tableName) {
+    this.tableName = tableName;
+    this.queryBuilder = this.db.queryBuilder().from(this.tableName);
+    return this;
+  }
+  /**
+   *
+   * @param columnName
+   * @returns
+   */
+  as(columnName) {
+    this.getQueryBuilder().as(columnName);
+    return this;
+  }
+  fromRaw(query) {
+    this.queryBuilder?.fromRaw(query);
+    return this;
+  }
+  /**
+   * Alias for from()
+   */
+  table(tableName) {
+    return this.from(tableName);
+  }
+  /**
+   * Select specific columns for the query.
+   * @param
+   */
+  select(...columns) {
+    this.queryBuilder = this.getQueryBuilder().select(
+      columns.length ? columns : "*"
+    );
+    return this;
+  }
+  whereJson(path, operator, value) {
+    const [jsonColumn, ...pathParts] = path.split(".");
+    const jsonPath = `$.${pathParts.join(".")}`;
+    if (!value) {
+      this.getQueryBuilder().whereRaw(`JSON_UNQUOTE(JSON_EXTRACT(??, ?)) = ?`, [
+        jsonColumn,
+        jsonPath,
+        operator,
+      ]);
+    } else {
+      this.getQueryBuilder().whereRaw(
+        `JSON_UNQUOTE(JSON_EXTRACT(??, ?)) ${operator} ?`,
+        [jsonColumn, jsonPath, operator]
+      );
+    }
+    return this;
+  }
+  /**
+   * Add a where clause to the query - Laravel style
+   *
+   * Supports multiple signatures:
+   * 1. where(callback) - Grouped conditions
+   * 2. where([...conditions]) - Array of conditions
+   * 3. where({key: value}) - Object syntax
+   * 4. where(column, value) - Two-argument form (assumes = operator)
+   * 5. where(column, operator, value) - Three-argument form
+   *
+   * @example
+   * // Closure for grouped conditions
+   * query.where((q) => {
+   *   q.where('age', '>', 18).orWhere('vip', true);
+   * });
+   *
+   * // Array of conditions
+   * query.where([
+   *   ['status', 'active'],
+   *   ['role', '=', 'admin']
+   * ]);
+   *
+   * // Object syntax
+   * query.where({ status: 'active', role: 'admin' });
+   *
+   * // Two-argument form
+   * query.where('status', 'active');
+   *
+   * // Three-argument form
+   * query.where('age', '>', 18);
+   */
+  where(column, operator, value) {
+    if (typeof column === "function") {
+      this.getQueryBuilder().where((qb) => {
+        const subQuery = new this.constructor();
+        subQuery.queryBuilder = qb;
+        column(subQuery);
+      });
+      return this;
+    }
+    if (Array.isArray(column)) {
+      column.forEach((condition) => {
+        if (condition.length === 2) {
+          this.where(condition[0], "=", condition[1]);
+        } else if (condition.length === 3) {
+          this.where(condition[0], condition[1], condition[2]);
+        }
+      });
+      return this;
+    }
+    if (
+      typeof column === "object" &&
+      column !== null &&
+      !Array.isArray(column)
+    ) {
+      Object.entries(column).forEach(([key, val]) => {
+        this.where(key, "=", val);
+      });
+      return this;
+    }
+    // Case 4 & 5: String column name
+    const isJson = column.includes(".") && !column.includes(" ");
+    // Two-argument form: where(column, value)
+    if (value === undefined && operator !== undefined && !isJson) {
+      this.getQueryBuilder().where(column, "=", operator);
+      return this;
+    }
+    // JSON path handling
+    if (isJson) {
+      this.whereJson(column, operator, value || "");
+      return this;
+    }
+    // Three-argument form: where(column, operator, value)
+    this.getQueryBuilder().where(column, operator, value || "");
+    return this;
+  }
+  whereNull(column) {
+    this.getQueryBuilder().whereNull(column);
+    return this;
+  }
+  whereNot(column, operator, value) {
+    if (value === undefined) {
+      this.getQueryBuilder().whereNot(column, operator);
+    } else {
+      this.getQueryBuilder().whereNot(column, operator, value);
+    }
+    return this;
+  }
+  orWhereNot(column, operator, value) {
+    if (value === undefined) {
+      this.getQueryBuilder().orWhereNot(column, operator);
+    } else {
+      this.getQueryBuilder().orWhereNot(column, operator, value);
+    }
+    return this;
+  }
+  whereNotNull(column) {
+    this.getQueryBuilder().whereNotNull(column);
+    return this;
+  }
+  whereExists(callback) {
+    return this.applyExists("whereRaw", callback);
+  }
+  orWhereExists(callback) {
+    return this.applyExists("orWhereRaw", callback);
+  }
+  whereBetween(column, range) {
+    this.getQueryBuilder().whereBetween(column, range);
+    return this;
+  }
+  orWhereBetween(column, range) {
+    this.getQueryBuilder().orWhereBetween(column, range);
+    return this;
+  }
+  whereNotBetween(column, range) {
+    this.getQueryBuilder().whereNotBetween(column, range);
+    return this;
+  }
+  orWhereNotBetween(column, range) {
+    this.getQueryBuilder().orWhereNotBetween(column, range);
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this.getQueryBuilder().orderBy(column, direction);
+    return this;
+  }
+  orderByRaw(query, bindings) {
+    this.getQueryBuilder().orderByRaw(query, bindings);
+    return this;
+  }
+  latest(column = "id") {
+    this.getQueryBuilder().orderBy(column, "desc");
+    return this;
+  }
+  older(column = "id") {
+    this.getQueryBuilder().orderBy(column, "asc");
+    return this;
+  }
+  having(column, operator, value) {
+    if (!value) {
+      this.getQueryBuilder().having(column, "=", operator);
+    } else {
+      this.getQueryBuilder().having(column, operator, value);
+    }
+    return this;
+  }
+  havingIn(column, values) {
+    this.getQueryBuilder().havingIn(column, values);
+    return this;
+  }
+  havingNotIn(column, values) {
+    this.getQueryBuilder().havingIn(column, values);
+    return this;
+  }
+  havingNull(column) {
+    this.getQueryBuilder().havingNull(column);
+    return this;
+  }
+  havingNotNull(column) {
+    this.getQueryBuilder().havingNotNull(column);
+    return this;
+  }
+  havingBetween(column, values) {
+    this.getQueryBuilder().havingBetween(column, values);
+    return this;
+  }
+  havingNotBetween(column, values) {
+    this.getQueryBuilder().havingNotBetween(column, values);
+    return this;
+  }
+  havingRaw(column, values) {
+    this.getQueryBuilder().havingRaw(column, values);
+    return this;
+  }
+  orWhere(column, operator, value) {
+    if (value === undefined) {
+      this.getQueryBuilder().orWhere(column, operator);
+    } else {
+      this.getQueryBuilder().orWhere(column, operator, value);
+    }
+    return this;
+  }
+  whereIn(column, values) {
+    if (typeof values === "function") {
+      this.getQueryBuilder().whereIn(column, function () {
+        values(this);
+      });
+    } else {
+      this.getQueryBuilder().whereIn(column, values);
+    }
+    return this;
+  }
+  whereLike(column, value) {
+    this.getQueryBuilder().whereLike(column, `%${value}%`);
+    return this;
+  }
+  andWhereLike(column, value) {
+    this.getQueryBuilder().andWhereLike(column, `%${value}%`);
+    return this;
+  }
+  orWhereLike(column, value) {
+    this.getQueryBuilder().orWhereLike(column, `%${value}%`);
+    return this;
+  }
+  joinRaw(sql, bindings) {
+    this.getQueryBuilder().joinRaw(sql, bindings);
+    return this;
+  }
+  join(table, columnOrCallback, operator, column2) {
+    return this.applyJoin("join", table, columnOrCallback, operator, column2);
+  }
+  innerJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "innerJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  toSQL() {
+    return this.getQueryBuilder().toSQL();
+  }
+  joinSub(subQuery, alias, callback) {
+    return this._joinSubWithType("INNER", subQuery, alias, callback);
+  }
+  leftJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "leftJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  rightJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "rightJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  leftOuterJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "leftOuterJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  rightOuterJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "rightOuterJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  fullOuterJoin(table, columnOrCallback, operator, column2) {
+    return this.applyJoin(
+      "fullOuterJoin",
+      table,
+      columnOrCallback,
+      operator,
+      column2
+    );
+  }
+  _joinSubWithType(type, subQuery, alias, callback) {
+    const { sql, bindings } = subQuery.toSQL();
+    const clauses = [];
+    const onBuilder = {
+      on(left, op, right) {
+        clauses.push(`${left} ${op} ${right}`);
+      },
+      onRaw(raw) {
+        clauses.push(raw);
+      },
+    };
+    callback(onBuilder);
+    const onClause = clauses.join(" ");
+    clauses.length = 0;
+    this.joinRaw(
+      `${type} JOIN (${this.raw(sql, bindings)}) AS ${alias} ${onClause}`
+    );
+    return this;
+  }
+  applyJoin(type, table, columnOrCallback, operator, column2) {
+    const qb = this.getQueryBuilder();
+    const self = this;
+    //
+    if (typeof columnOrCallback === "function") {
+      qb.join(table, function () {
+        columnOrCallback(self.applyJoinHelper(this));
+      });
+    } else if (operator && column2) {
+      qb.join(table, columnOrCallback, operator, column2);
+    } else {
+      throw new Error(`Invalid ${type} parameters`);
+    }
+    return this;
+  }
+  crossJoinSub(subQuery, alias) {
+    const { sql, bindings } = subQuery.toSQL();
+    this.joinRaw(`CROSS JOIN (${this.raw(sql, bindings)}) AS ${alias}`);
+    return this;
+  }
+  leftJoinSub(subQuery, alias, callback) {
+    return this._joinSubWithType("LEFT", subQuery, alias, callback);
+  }
+  rightJoinSub(subQuery, alias, callback) {
+    return this._joinSubWithType("RIGHT", subQuery, alias, callback);
+  }
+  clearSelect() {
+    this.getQueryBuilder().clearSelect();
+    return this;
+  }
+  clearGroup() {
+    this.getQueryBuilder().clearGroup();
+    return this;
+  }
+  clearHaving() {
+    this.getQueryBuilder().clearHaving();
+    return this;
+  }
+  clearWhere() {
+    this.getQueryBuilder().clearWhere();
+    return this;
+  }
+  distinct(...columns) {
+    this.getQueryBuilder().distinct(columns);
+    return this;
+  }
+  groupBy(...columns) {
+    this.getQueryBuilder().groupBy(columns);
+    return this;
+  }
+  groupByRaw(query, bindings) {
+    this.getQueryBuilder().groupByRaw(query, bindings);
+    return this;
+  }
+  async get() {
+    const result = this.getQueryBuilder().clone();
+    this.reset();
+    return result;
+  }
+  async first() {
+    const result = await this.limit(1).get();
+    this.reset();
+    return result.length ? result[0] : null;
+  }
+  clone() {
+    const clone = new Builder();
+    clone.queryBuilder = this.getQueryBuilder().clone();
+    clone.tableName = this.tableName;
+    clone.model = this.model;
+    clone.db = this.db;
+    clone.eagerLoad = [...this.eagerLoad];
+    clone.softDelete = this.softDelete;
+    return clone;
+  }
+  /**
+   * Check if any record exists for the current query.
+   */
+  async exists() {
+    const result = await this.first();
+    this.reset();
+    return !!result;
+  }
+  /**
+   * Check if no record exists for the current query.
+   */
+  async doesntExist() {
+    return !(await this.exists());
+  }
+  /**
+   * Get a single column's value from the first result.
+   */
+  async value(column) {
+    const row = await this.first();
+    return row ? row[column] : null;
+  }
+  async insert(data) {
+    const result = await this.db(this.tableName).insert(data);
+    this.reset();
+    return result && Array.isArray(result) ? result[0] : result;
+  }
+  async update(data) {
+    let result = false;
+    for (const key in data) {
+      if (key.includes(".")) {
+        result = await this.updateJson(key, data[key]);
+        delete data[key];
+      }
+    }
+    if (Object.keys(data).length > 0) {
+      result = await this.getQueryBuilder().update(data);
+    }
+    this.reset();
+    return result ? true : false;
+  }
+  async delete() {
+    const result = await this.getQueryBuilder().delete();
+    this.reset();
+    return result;
+  }
+  raw(query, bindings = []) {
+    return this.db.raw(query, bindings);
+  }
+  whereRaw(query, bindings = []) {
+    this.getQueryBuilder().whereRaw(query, bindings);
+    return this;
+  }
+  orWhereRaw(query, bindings = []) {
+    this.getQueryBuilder().orWhereRaw(query, bindings);
+    return this;
+  }
+  async runQuery(query, bindings = []) {
+    const res = await this.db.raw(query, bindings);
+    return res?.rows ? res?.rows : res;
+  }
+  returning(columns) {
+    this.getQueryBuilder().returning(columns);
+    return this;
+  }
+  offset(value) {
+    this.getQueryBuilder().offset(value);
+    return this;
+  }
+  limit(value) {
+    this.getQueryBuilder().limit(value);
+    return this;
+  }
+  union(queries) {
+    return this.applyUnion("union", queries);
+  }
+  unionAll(queries) {
+    return this.applyUnion("unionAll", queries);
+  }
+  toSqlCode() {
+    return this.queryBuilder.toSQL().sql;
+  }
+  max(columns) {
+    return this.applyAggregate("max", columns);
+  }
+  async count(columns = "id") {
+    this.applyAggregate("count", columns);
+    return utils_1.Utils.countValue(await this.first());
+  }
+  min(columns) {
+    return this.applyAggregate("min", columns);
+  }
+  sum(columns) {
+    return this.applyAggregate("sum", columns);
+  }
+  avg(columns) {
+    return this.applyAggregate("avg", columns);
+  }
+  increment(column, amount) {
+    if (typeof column === "string") {
+      this.queryBuilder.increment(column, amount ?? 1);
+    } else {
+      this.queryBuilder.increment(column); // object form { col1: value1, col2: value2 }
+    }
+    return this;
+  }
+  truncate() {
+    this.queryBuilder.truncate();
+    return this;
+  }
+  async paginate(request, perPage = 15) {
+    const page = Math.max(1, Number(request.query.page) || 1);
+    const offset = (page - 1) * Number(perPage);
+    const count = await this.clone().count();
+    const total = count;
+    const data = await this.clone().offset(offset).limit(Number(perPage)).get();
+    const totalPages = Math.ceil(total / Number(perPage));
+    const path = `${request.protocol}://${request.get("host")}${request.path}`;
+    return {
+      data: data,
+      meta: {
+        current_page: page,
+        per_page: perPage,
+        total: total,
+        total_pages: totalPages,
+        has_more: page < totalPages,
+        links: utils_1.Utils.generatePaginationLinks(path, page, totalPages),
+      },
+      links: {
+        first: `${path}?page=1`,
+        last: `${path}?page=${totalPages}`,
+      },
+    };
+  }
+  plunk(column) {
+    this.getQueryBuilder().pluck(column);
+    return this;
+  }
+  /**
+   * Get an array of values for a single column (alias like Laravel pluck).
+   */
+  async pluck(column) {
+    const result = await this.queryBuilder.pluck(column);
+    this.reset();
+    return result;
+  }
+  decrement(column, amount) {
+    if (typeof column === "string") {
+      this.getQueryBuilder().decrement(column, amount ?? 1);
+    } else {
+      this.getQueryBuilder().decrement(column); // object form
+    }
+    return this;
+  }
+  async updateJson(path, value) {
+    const [column, ...jsonPathParts] = path.split(".");
+    const jsonPath = "$." + jsonPathParts.join(".");
+    const result = await this.getQueryBuilder().update({
+      [column]: this.db.raw(`JSON_SET(??, ?, ?)`, [column, jsonPath, value]),
+    });
+    this.reset();
+    return result ? true : false;
+  }
+  applyJoinHelper(joinBuilder) {
+    const db = this.db; // or however you access knex
+    const helper = {
+      on: (c1, op, c2) => {
+        joinBuilder.on(c1, op, c2);
         return helper;
-    }
-    whereColumn(column, operator, value) {
-        return this.applyColumn("whereColumn", column, operator, value);
-    }
-    orWhereColumn(column, operator, value) {
-        return this.applyColumn("orWhereColumn", column, operator, value);
-    }
-    whereNotColumn(column, operator, value) {
-        return this.applyColumn("whereNotColumn", column, operator, value);
-    }
-    applyExists(method, callback) {
-        const sub = this.getQueryBuilder();
-        callback(sub);
-        const { sql, bindings } = sub.clone().toSQL();
-        this.getQueryBuilder()[method](`exists (${sql})`, bindings);
-        return this;
-    }
-    applyColumn(type, column, operator, value) {
-        if (!value) {
-            this.getQueryBuilder()[type](column, operator);
-        }
-        else {
-            this.getQueryBuilder()[type](column, operator, value);
-        }
-        return this;
-    }
-    applyAggregate(type, columns) {
-        const qb = this.getQueryBuilder();
-        if (typeof columns === "string") {
-            switch (type) {
-                case "max":
-                    qb.max(columns);
-                    break;
-                case "min":
-                    qb.min(columns);
-                    break;
-                case "sum":
-                    qb.sum(columns);
-                    break;
-                case "avg":
-                    qb.avg(columns);
-                    break;
-                case "count":
-                    qb.count(columns);
-                    break;
-            }
-        }
-        else if (Array.isArray(columns)) {
-            columns.forEach((col) => {
-                switch (type) {
-                    case "max":
-                        qb.max(col);
-                        break;
-                    case "min":
-                        qb.min(col);
-                        break;
-                    case "sum":
-                        qb.sum(col);
-                        break;
-                    case "avg":
-                        qb.avg(col);
-                        break;
-                    case "count":
-                        qb.count(col);
-                        break;
-                }
-            });
-        }
-        else {
-            Object.entries(columns).forEach(([alias, col]) => {
-                const expr = `${col} as ${alias}`;
-                switch (type) {
-                    case "max":
-                        qb.max(expr);
-                        break;
-                    case "min":
-                        qb.min(expr);
-                        break;
-                    case "sum":
-                        qb.sum(expr);
-                        break;
-                    case "avg":
-                        qb.avg(expr);
-                        break;
-                    case "count":
-                        qb.count(expr);
-                        break;
-                }
-            });
-        }
-        return this;
-    }
-    applyUnion(type, queries) {
-        const qb = this.getQueryBuilder();
-        if (typeof queries === "function") {
-            qb[type](queries);
-        }
-        else if (Array.isArray(queries)) {
-            const queryBuilders = queries.map((q) => q.getQueryBuilder());
-            qb[type](queryBuilders);
-        }
-        else {
-            qb[type](queries);
-        }
-        return this;
-    }
-    reset() {
-        this.queryBuilder = null;
-        // this.tableName = "";
-    }
+      },
+      orOn: (c1, op, c2) => {
+        joinBuilder.orOn(c1, op, c2);
+        return helper;
+      },
+      raw: (sql, bindings = []) => {
+        joinBuilder.on(db.raw(sql, bindings));
+        return helper;
+      },
+    };
+    return helper;
+  }
+  whereColumn(column, operator, value) {
+    return this.applyColumn("whereColumn", column, operator, value);
+  }
+  orWhereColumn(column, operator, value) {
+    return this.applyColumn("orWhereColumn", column, operator, value);
+  }
+  whereNotColumn(column, operator, value) {
+    return this.applyColumn("whereNotColumn", column, operator, value);
+  }
+  applyExists(method, callback) {
+    const sub = this.getQueryBuilder();
+    callback(sub);
+    const { sql, bindings } = sub.clone().toSQL();
+    this.getQueryBuilder()[method](`exists (${sql})`, bindings);
+    return this;
+  }
+  applyColumn(type, column, operator, value) {
+    if (!value) {
+      this.getQueryBuilder()[type](column, operator);
+    } else {
+      this.getQueryBuilder()[type](column, operator, value);
+    }
+    return this;
+  }
+  applyAggregate(type, columns) {
+    const qb = this.getQueryBuilder();
+    if (typeof columns === "string") {
+      switch (type) {
+        case "max":
+          qb.max(columns);
+          break;
+        case "min":
+          qb.min(columns);
+          break;
+        case "sum":
+          qb.sum(columns);
+          break;
+        case "avg":
+          qb.avg(columns);
+          break;
+        case "count":
+          qb.count(columns);
+          break;
+      }
+    } else if (Array.isArray(columns)) {
+      columns.forEach((col) => {
+        switch (type) {
+          case "max":
+            qb.max(col);
+            break;
+          case "min":
+            qb.min(col);
+            break;
+          case "sum":
+            qb.sum(col);
+            break;
+          case "avg":
+            qb.avg(col);
+            break;
+          case "count":
+            qb.count(col);
+            break;
+        }
+      });
+    } else {
+      Object.entries(columns).forEach(([alias, col]) => {
+        const expr = `${col} as ${alias}`;
+        switch (type) {
+          case "max":
+            qb.max(expr);
+            break;
+          case "min":
+            qb.min(expr);
+            break;
+          case "sum":
+            qb.sum(expr);
+            break;
+          case "avg":
+            qb.avg(expr);
+            break;
+          case "count":
+            qb.count(expr);
+            break;
+        }
+      });
+    }
+    return this;
+  }
+  applyUnion(type, queries) {
+    const qb = this.getQueryBuilder();
+    if (typeof queries === "function") {
+      qb[type](queries);
+    } else if (Array.isArray(queries)) {
+      const queryBuilders = queries.map((q) => q.getQueryBuilder());
+      qb[type](queryBuilders);
+    } else {
+      qb[type](queries);
+    }
+    return this;
+  }
+  reset() {
+    this.queryBuilder = null;
+    // this.tableName = "";
+  }
 }
 exports.Builder = Builder;