@carbonorm/carbonnode 3.0.13 → 3.1.2

package/src/api/executors/HttpExecutor.ts

@@ -5,6 +5,7 @@ import isTest from "../../variables/isTest";
 import isVerbose from "../../variables/isVerbose";
 import convertForRequestBody from "../convertForRequestBody";
 import {eFetchDependencies} from "../types/dynamicFetching";
+import {OrmGenerics} from "../types/ormGenerics";
 import {
     apiReturn,
     DELETE, DetermineResponseDataType,
@@ -12,7 +13,6 @@ import {
     iCacheAPI,
     iConstraint,
     iGetC6RestResponse,
-    iRestMethods,
     POST,
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
@@ -23,36 +23,24 @@ import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
 
 export class HttpExecutor<
-    RequestMethod extends iRestMethods,
-    RestShortTableName extends string = any,
-    RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
-    CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+    G extends OrmGenerics
 >
-    extends Executor<
-        RequestMethod,
-        RestShortTableName,
-        RestTableInterface,
-        PrimaryKey,
-        CustomAndRequiredFields,
-        RequestTableOverrides
-    > {
+    extends Executor<G> {
 
     public putState(
-        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
-        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
-                removeInvalidKeys<RestTableInterface>({
+                removeInvalidKeys<G['RestTableInterface']>({
                     ...request,
                     ...response?.data?.rest,
                 }, this.config.C6.TABLES)
@@ -63,12 +51,12 @@ export class HttpExecutor<
     }
 
     public postState(
-        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
@@ -87,49 +75,49 @@ export class HttpExecutor<
 
         }
 
-        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: undefined !== request.dataInsertMultipleRows
                 ? request.dataInsertMultipleRows.map((request, index) => {
-                    return removeInvalidKeys<RestTableInterface>({
+                    return removeInvalidKeys<G['RestTableInterface']>({
                         ...request,
                         ...(index === 0 ? response?.data?.rest : {}),
                     }, this.config.C6.TABLES)
                 })
                 : [
-                    removeInvalidKeys<RestTableInterface>({
+                    removeInvalidKeys<G['RestTableInterface']>({
                         ...request,
                         ...response?.data?.rest,
                     }, this.config.C6.TABLES)
                 ],
             stateKey: this.config.restModel.TABLE_NAME,
-            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[]
         })
     }
 
     public deleteState(
-        _response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        _response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
-        this.config.reactBootstrap?.deleteRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.deleteRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
-                request as unknown as RestTableInterface,
+                request as unknown as G['RestTableInterface'],
             ],
             stateKey: this.config.restModel.TABLE_NAME,
-            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[]
         })
     }
 
-    public async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
+    public async execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
 
-        type ResponseDataType = DetermineResponseDataType<RequestMethod, RestTableInterface>;
+        type ResponseDataType = DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
 
         const {
             C6,
@@ -151,7 +139,7 @@ export class HttpExecutor<
             });
 
 
-        const tableName = restModel.TABLE_NAME;
+        const tableName = restModel.TABLE_NAME as string;
 
         const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
 
@@ -218,7 +206,7 @@ export class HttpExecutor<
         }
 
         // this could return itself with a new page number, or undefined if the end is reached
-        const apiRequest = async (): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> => {
+        const apiRequest = async (): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> => {
 
             const {
                 debug,
@@ -261,10 +249,10 @@ export class HttpExecutor<
                     if (undefined === query || null === query) {
 
                         query = {} as RequestQueryBody<
-                            RequestMethod,
-                            RestTableInterface,
-                            CustomAndRequiredFields,
-                            RequestTableOverrides
+                            G['RequestMethod'],
+                            G['RestTableInterface'],
+                            G['CustomAndRequiredFields'],
+                            G['RequestTableOverrides']
                         >
 
                     }
@@ -351,7 +339,7 @@ export class HttpExecutor<
 
             let addBackPK: (() => void) | undefined;
 
-            let apiResponse: RestTableInterface[PrimaryKey] | string | boolean | number | undefined;
+            let apiResponse: G['RestTableInterface'][G['PrimaryKey']] | string | boolean | number | undefined;
 
             let returnGetNextPageFunction = false;
 
@@ -427,10 +415,10 @@ export class HttpExecutor<
 
                 addBackPK = () => {
                     query ??= {} as RequestQueryBody<
-                        RequestMethod,
-                        RestTableInterface,
-                        CustomAndRequiredFields,
-                        RequestTableOverrides
+                        G['RequestMethod'],
+                        G['RestTableInterface'],
+                        G['CustomAndRequiredFields'],
+                        G['RequestTableOverrides']
                     >;
                     query[primaryKey] = removedPkValue;
                 }
@@ -470,10 +458,10 @@ export class HttpExecutor<
                     ...(() => {
                         const convert = (data: any) =>
                             convertForRequestBody<
-                                RequestMethod,
-                                RestTableInterface,
-                                CustomAndRequiredFields,
-                                RequestTableOverrides
+                                G['RequestMethod'],
+                                G['RestTableInterface'],
+                                G['CustomAndRequiredFields'],
+                                G['RequestTableOverrides']
                             >(
                                 data,
                                 fullTableList,
@@ -574,7 +562,6 @@ export class HttpExecutor<
                         if (false === apiResponse) {
 
 
-
                             if (debug && isLocal()) {
 
                                 toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
@@ -596,10 +583,10 @@ export class HttpExecutor<
                         if (undefined !== reactBootstrap && response) {
                             switch (requestMethod) {
                                 case GET:
-                                    reactBootstrap.updateRestfulObjectArrays<RestTableInterface>({
+                                    reactBootstrap.updateRestfulObjectArrays<G['RestTableInterface']>({
                                         dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
                                         stateKey: this.config.restModel.TABLE_NAME,
-                                        uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[],
+                                        uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[],
                                         callback
                                     })
                                     break;

package/src/api/executors/SqlExecutor.ts

@@ -1,32 +1,23 @@
-import { SqlBuilder } from "api/builders/sqlBuilder";
+import {SelectQueryBuilder} from "../orm/queries/SelectQueryBuilder";
+import {OrmGenerics} from "../types/ormGenerics";
 import {
     apiReturn,
     DetermineResponseDataType,
     iPostC6RestResponse,
     iPutC6RestResponse,
-    iDeleteC6RestResponse,
-    iRestMethods
+    iDeleteC6RestResponse
 } from "../types/ormInterfaces";
-import { PoolConnection, RowDataPacket, ResultSetHeader } from 'mysql2/promise';
+import namedPlaceholders from 'named-placeholders';
+import {PoolConnection, RowDataPacket, ResultSetHeader} from 'mysql2/promise';
+import {Buffer} from 'buffer';
+import {Executor} from "./Executor";
 
 export class SqlExecutor<
-    RequestMethod extends iRestMethods,
-    RestShortTableName extends string = any,
-    RestTableInterface extends Record<string, any> = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
-    CustomAndRequiredFields extends Record<string, any> = any,
-    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
-> extends SqlBuilder<
-    RequestMethod,
-    RestShortTableName,
-    RestTableInterface,
-    PrimaryKey,
-    CustomAndRequiredFields,
-    RequestTableOverrides
-> {
-
-    async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
-        const { TABLE_NAME } = this.config.restModel;
+    G extends OrmGenerics
+> extends Executor<G>{
+
+    async execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
+        const {TABLE_NAME} = this.config.restModel;
         const method = this.config.requestMethod;
 
         console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
@@ -36,25 +27,25 @@ export class SqlExecutor<
             case 'GET': {
                 const rest = await this.select(TABLE_NAME, undefined, this.request);
                 console.log(`[SQL EXECUTOR] ✅ GET result:`, rest);
-                return { rest } as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return rest as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'POST': {
                 const result = await this.insert(TABLE_NAME, this.request);
                 console.log(`[SQL EXECUTOR] ✅ POST result:`, result);
-                const created: iPostC6RestResponse = { rest: result, created: true };
-                return created as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                const created: iPostC6RestResponse = {rest: result, created: true};
+                return created as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'PUT': {
                 const result = await this.update(TABLE_NAME, [], this.request);
                 console.log(`[SQL EXECUTOR] ✅ PUT result:`, result);
                 const updated: iPutC6RestResponse = {
-                    rest: result,
+                    ...result,
                     updated: true,
-                    rowCount: (result as ResultSetHeader).affectedRows
+                    rowCount: result.rest.affectedRows
                 };
-                return updated as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return updated as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'DELETE': {
@@ -63,9 +54,9 @@ export class SqlExecutor<
                 const deleted: iDeleteC6RestResponse = {
                     rest: result,
                     deleted: true,
-                    rowCount: (result as ResultSetHeader).affectedRows
+                    rowCount: result.rest.affectedRows
                 };
-                return deleted as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return deleted as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             default:
@@ -85,40 +76,58 @@ export class SqlExecutor<
         }
     }
 
-    async select<TName extends string>(table: TName, primary: string | undefined, args: any) {
-        const sql = this.buildSelectQuery<TName>(table, primary, args);
-        console.log(`[SQL EXECUTOR] 🧠 Generated SELECT SQL:`, sql);
-        const formatted = this.formatSQLWithParams(sql.sql, sql.params);
-        console.log(`[SQL EXECUTOR] 🧠 Formatted SELECT SQL:`, formatted);
+    public serialize = (row: any) => Object.fromEntries(Object.entries(row).map(
+        ([k, v]) => [k, Buffer.isBuffer(v) ? v.toString('hex').toUpperCase() : v]
+    ));
 
+    async select(table: G['RestShortTableName'], primary: string | undefined, args: any) {
+        const QueryResult = (new SelectQueryBuilder(this.config, this.request)).build(table, args, primary);
+        console.log(`[SQL EXECUTOR] 🧠 Generated SELECT SQL:`, QueryResult);
+        const formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
+        console.log(`[SQL EXECUTOR] 🧠 Formatted SELECT SQL:`, formatted);
+        const toUnnamed = namedPlaceholders();
+        const [sql, values] = toUnnamed(QueryResult.sql, QueryResult.params);
         return await this.withConnection(async (conn) => {
-            const [rows] = await conn.query<RowDataPacket[]>(sql.sql, sql.params);
+            const [rows] = await conn.query<RowDataPacket[]>(sql, values);
             console.log(`[SQL EXECUTOR] 📦 Rows fetched:`, rows);
-            return rows;
+            return {
+                rest: rows.map(this.serialize),
+                sql: {
+                    sql, values
+                }
+            };
         });
     }
 
-    async insert<TName extends string>(table: TName, data: Record<string, any>) {
+    async insert(table: G['RestShortTableName'], data: Record<string, any>) {
         const keys = Object.keys(data);
         const values = keys.map(k => data[k]);
         const placeholders = keys.map(() => '?').join(', ');
-        const sql = `INSERT INTO \`${table}\` (${keys.join(', ')}) VALUES (${placeholders})`;
+        const sql = `INSERT INTO \`${table}\` (${keys.join(', ')})
+                     VALUES (${placeholders})`;
 
         console.log(`[SQL EXECUTOR] 🧠 Generated INSERT SQL:`, sql);
         console.log(`[SQL EXECUTOR] 🔢 Values:`, values);
 
         return await this.withConnection(async (conn) => {
             const [result] = await conn.execute<ResultSetHeader>(sql, values);
-            return result;
+            return {
+                rest: result,
+                sql: {
+                    sql, placeholders
+                }
+            };
         });
     }
 
-    async update<TName extends string>(table: TName, primary: string[], data: Record<string, any>) {
+    async update(table: G['RestShortTableName'], primary: string[], data: Record<string, any>) {
         if (!primary?.length) throw new Error('Primary key is required for update');
         const keys = Object.keys(data);
         const values = keys.map(k => data[k]);
         const updates = keys.map(k => `\`${k}\` = ?`).join(', ');
-        const sql = `UPDATE \`${table}\` SET ${updates} WHERE \`${primary[0]}\` = ?`;
+        const sql = `UPDATE \`${table}\`
+                     SET ${updates}
+                     WHERE \`${primary[0]}\` = ?`;
         values.push(data[primary[0]]);
 
         console.log(`[SQL EXECUTOR] 🧠 Generated UPDATE SQL:`, sql);
@@ -126,38 +135,60 @@ export class SqlExecutor<
 
         return await this.withConnection(async (conn) => {
             const [result] = await conn.execute<ResultSetHeader>(sql, values);
-            return result;
+            return {
+                rest:result,
+                sql: {
+                    sql, values
+                }
+            };
         });
     }
 
-    async delete<TName extends string>(table: TName, primary: string[], args: Record<string, any>) {
+    async delete(table: G['RestShortTableName'], primary: string[], args: Record<string, any>) {
         const key = primary?.[0];
         if (!key || !args?.[key]) throw new Error('Primary key and value required for delete');
-        const sql = `DELETE FROM \`${table}\` WHERE \`${key}\` = ?`;
+        const sql = `DELETE
+                     FROM \`${table}\`
+                     WHERE \`${key}\` = ?`;
 
         console.log(`[SQL EXECUTOR] 🧠 Generated DELETE SQL:`, sql);
         console.log(`[SQL EXECUTOR] 🔢 Value:`, args[key]);
 
         return await this.withConnection(async (conn) => {
             const [result] = await conn.execute<ResultSetHeader>(sql, [args[key]]);
-            return result;
+            return {
+                rest: result,
+                sql: {
+                    sql, args
+                }
+            };
         });
     }
 
+    public formatSQLWithParams(sql: string, params: any[] | { [key: string]: any }): string {
+        if (Array.isArray(params)) {
+            let index = 0;
+            return sql.replace(/\?/g, () => {
+                if (index >= params.length) return '?';
+                const val = params[index++];
+                return this.formatValue(val);
+            });
+        } else {
+            return sql.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+                const val = params[key];
+                return this.formatValue(val);
+            });
+        }
+    }
 
-    public formatSQLWithParams(sql: string, params: any[]): string {
-        let index = 0;
-
-        return sql.replace(/\?/g, () => {
-            if (index >= params.length) return '?'; // fallback if params are missing
-            const val = params[index++];
-            if (val === null || val === undefined) return 'NULL';
-            if (Buffer.isBuffer(val)) return `UNHEX('${val.toString('hex')}')`;
-            if (typeof val === 'string') return `'${val.replace(/'/g, "''")}'`;
-            if (typeof val === 'number') return val.toString();
-            if (val instanceof Date) return `'${val.toISOString().slice(0, 19).replace('T', ' ')}'`;
-            return `'${JSON.stringify(val)}'`;
-        });
+    private formatValue(val: any): string {
+        if (val === null || val === undefined) return 'NULL';
+        if (Buffer.isBuffer(val)) return `UNHEX('${val.toString('hex')}')`;
+        if (typeof val === 'string') return `'${val.replace(/'/g, "''")}'`;
+        if (typeof val === 'number') return val.toString();
+        if (val instanceof Date) return `'${val.toISOString().slice(0, 19).replace('T', ' ')}'`;
+        return `'${JSON.stringify(val)}'`;
     }
 
+
 }

package/src/api/handlers/ExpressHandler.ts

@@ -38,6 +38,7 @@ export function ExpressHandler({C6, mysqlPool}: { C6: iC6Object, mysqlPool: Pool
                     res.status(405).json({error: `Method ${method} not allowed`});
                     return;
             }
+
             const response = await restRequest({
                 C6,
                 mysqlPool,
@@ -45,10 +46,10 @@ export function ExpressHandler({C6, mysqlPool}: { C6: iC6Object, mysqlPool: Pool
                 restModel: C6.TABLES[table]
             })(payload);
 
-            console.log('response', JSON.stringify(response));
-
             res.status(200).json({success: true, ...response});
+
         } catch (err) {
+            res.status(500).json({success: false, error: err});
             next(err);
         }
     };

package/src/api/orm/builders/AggregateBuilder.ts

@@ -0,0 +1,38 @@
+import isVerbose from "../../../variables/isVerbose";
+import {Executor} from "../../executors/Executor";
+import {OrmGenerics} from "../../types/ormGenerics";
+
+export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G>{
+    buildAggregateField(field: string | any[]): string {
+        if (typeof field === 'string') {
+            return field;
+        }
+
+        if (!Array.isArray(field) || field.length === 0) {
+            throw new Error('Invalid SELECT field entry');
+        }
+
+        let [fn, ...args] = field;
+        let alias: string | undefined;
+
+        if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
+            alias = String(args.pop());
+            args.pop();
+        }
+
+        const F = String(fn).toUpperCase();
+        const argList = args.map(arg =>
+            Array.isArray(arg) ? this.buildAggregateField(arg) : arg
+        ).join(', ');
+
+        let expr = `${F}(${argList})`;
+
+        if (alias) {
+            expr += ` AS ${alias}`;
+        }
+
+        isVerbose() && console.log(`[SELECT] ${expr}`);
+
+        return expr;
+    }
+}

package/src/api/orm/builders/ConditionBuilder.ts

@@ -0,0 +1,113 @@
+import {C6Constants} from "api/C6Constants";
+import isVerbose from "../../../variables/isVerbose";
+import {OrmGenerics} from "../../types/ormGenerics";
+import {apiReturn, DetermineResponseDataType} from "../../types/ormInterfaces";
+import {convertHexIfBinary} from "../utils/sqlUtils";
+import {AggregateBuilder} from "./AggregateBuilder";
+
+export class ConditionBuilder<
+    G extends OrmGenerics
+> extends AggregateBuilder<G> {
+    execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
+        throw new Error("Method not implemented.");
+    }
+
+    private readonly OPERATORS = new Set([
+        '=', '!=', '<', '<=', '>', '>=',
+        'LIKE', 'NOT LIKE', 'IN', 'NOT IN',
+        'IS', 'IS NOT', 'BETWEEN', 'NOT BETWEEN',
+        C6Constants.MATCH_AGAINST
+    ]);
+
+    private validateOperator(op: string) {
+        if (!this.OPERATORS.has(op)) {
+            throw new Error(`Invalid or unsupported SQL operator detected: '${op}'`);
+        }
+    }
+
+    private addParam(
+        params: any[] | Record<string, any>,
+        column: string,
+        value: any
+    ): string {
+        const columnDef = this.config.C6[column.split('.')[0]]?.TYPE_VALIDATION?.[column];
+        const val = convertHexIfBinary(column, value, columnDef);
+
+        if (this.useNamedParams) {
+            const key = `param${Object.keys(params).length}`;
+            (params as Record<string, any>)[key] = val;
+            return `:${key}`;
+        } else {
+            (params as any[]).push(val);
+            return '?';
+        }
+    }
+
+    buildBooleanJoinedConditions(
+        set: any,
+        andMode: boolean = true,
+        params: any[] | Record<string, any> = []
+    ): string {
+        const booleanOperator = andMode ? 'AND' : 'OR';
+
+        const addCondition = (column: string, op: string, value: any): string => {
+            this.validateOperator(op);
+
+
+            if (op === C6Constants.MATCH_AGAINST && Array.isArray(value)) {
+                const [search, mode] = value;
+                const paramName = this.useNamedParams ? `param${Object.keys(params).length}` : null;
+                if (this.useNamedParams) {
+                    params[paramName!] = search;
+                } else {
+                    params.push(search);
+                }
+
+                let againstClause: string;
+
+                switch ((mode || '').toUpperCase()) {
+                    case 'BOOLEAN':
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} IN BOOLEAN MODE)` : `AGAINST(? IN BOOLEAN MODE)`;
+                        break;
+                    case 'WITH QUERY EXPANSION':
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} WITH QUERY EXPANSION)` : `AGAINST(? WITH QUERY EXPANSION)`;
+                        break;
+                    default: // NATURAL or undefined
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName})` : `AGAINST(?)`;
+                        break;
+                }
+
+                const matchClause = `(MATCH(${column}) ${againstClause})`;
+                isVerbose() && console.log(`[MATCH_AGAINST] ${matchClause}`);
+                return matchClause;
+            }
+
+            // handle other operators
+            return `( ${column} ${op} ${this.addParam(params, column, value)} )`;
+        };
+
+        const parts: string[] = [];
+
+        if (typeof set === 'object' && !Array.isArray(set)) {
+            for (const [key, value] of Object.entries(set)) {
+                if (typeof value === 'object' && value !== null && Object.keys(value).length === 1) {
+                    const [op, val] = Object.entries(value)[0];
+                    parts.push(addCondition(key, op, val));
+                } else {
+                    parts.push(addCondition(key, '=', value));
+                }
+            }
+        }
+
+        const clause = parts.join(` ${booleanOperator} `);
+        return clause ? `(${clause})` : '';
+    }
+
+    buildWhereClause(whereArg: any, params: any[] | Record<string, any>): string {
+        const clause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        if (!clause) return '';
+        const trimmed = clause.replace(/^\((.*)\)$/, '$1');
+        isVerbose() && console.log(`[WHERE] ${trimmed}`);
+        return ` WHERE ${trimmed}`;
+    }
+}