@carbonorm/carbonnode 3.0.10 → 3.0.12

package/src/api/builders/sqlBuilder.ts

@@ -1,173 +1,223 @@
-import { C6Constants } from "api/C6Constants";
-
-export function buildBooleanJoinedConditions(set: any, andMode = true): string {
-    const booleanOperator = andMode ? 'AND' : 'OR';
-    let sql = '';
-
-    const OPERATORS = ['=', '!=', '<', '<=', '>', '>=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT'];
-
-    const isAggregateArray = (value: any) => Array.isArray(value) && typeof value[0] === 'string' && OPERATORS.includes(value[0]);
-
-    const isNumericKeyed = (obj: any) => Array.isArray(obj) && Object.keys(obj).every(k => /^\d+$/.test(k));
-
-    // todo - we should be doing something with value no????
-    const addCondition = (column: string, op: string, _value: any): string => {
-        const paramName = column.replace(/\W+/g, '_');
-        return `(${column} ${op} :${paramName})`;
-    };
-
-    if (isNumericKeyed(set)) {
-        switch (set.length) {
-            case 2:
-                sql += addCondition(set[0], '=', set[1]);
-                break;
-            case 3:
-                if (!OPERATORS.includes(set[1])) {
-                    throw new Error(`Invalid operator: ${set[1]}`);
-                }
-                sql += addCondition(set[0], set[1], set[2]);
-                break;
-            default:
-                throw new Error(`Invalid array condition: ${JSON.stringify(set)}`);
-        }
-    } else {
-        const parts: string[] = [];
-        for (const [key, value] of Object.entries(set)) {
-            if (/^\d+$/.test(key)) {
-                parts.push(buildBooleanJoinedConditions(value, !andMode));
-                continue;
-            }
+import {C6Constants} from "api/C6Constants";
+import isVerbose from "../../variables/isVerbose";
+import {Executor} from "../executors/Executor";
+import {iRestMethods} from "../types/ormInterfaces";
+
+interface QueryResult {
+    sql: string;
+    params: any[];
+}
 
-            if (!Array.isArray(value) || isAggregateArray(value)) {
-                parts.push(addCondition(key, '=', value));
-                continue;
+export abstract class SqlBuilder<
+    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 { [key: string]: any } = any,
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+> extends Executor<
+    RequestMethod,
+    RestShortTableName,
+    RestTableInterface,
+    PrimaryKey,
+    CustomAndRequiredFields,
+    RequestTableOverrides
+> {
+    /** Generate nested WHERE/JOIN conditions with parameter binding */
+    protected buildBooleanJoinedConditions(
+        set: any,
+        andMode = true,
+        params: any[] = []
+    ): string {
+        const booleanOperator = andMode ? 'AND' : 'OR';
+        const OPERATORS = ['=', '!=', '<', '<=', '>', '>=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT'];
+
+        const isAggregateArray = (value: any) =>
+            Array.isArray(value) && typeof value[0] === 'string' && OPERATORS.includes(value[0]);
+        const isNumericKeyed = (obj: any) =>
+            Array.isArray(obj) && Object.keys(obj).every(k => /^\d+$/.test(k));
+
+        const addCondition = (column: string, op: string, value: any): string => {
+            let clause: string;
+            /*if (Buffer.isBuffer(value)) { // TODO - I want this as a parameterized option, for now default to faster
+                params.push(value.toString('hex')); // Or use UNHEX(?) in SQL
+                clause = `(${column} = UNHEX(?))`;
+            } else {*/
+                params.push(value);
+                clause = `( ${column} ${op} ? )`;
+            //}
+            isVerbose() && console.log(`[WHERE] ➕ ${clause} ->`, value);
+            return clause;
+        };
+
+        let sql: string;
+        if (isNumericKeyed(set)) {
+            isVerbose() && console.log(`[WHERE] Numeric keyed condition:`, set);
+            switch (set.length) {
+                case 2:
+                    sql = addCondition(set[0], '=', set[1]);
+                    break;
+                case 3:
+                    if (!OPERATORS.includes(set[1])) throw new Error(`Invalid operator: ${set[1]}`);
+                    sql = addCondition(set[0], set[1], set[2]);
+                    break;
+                default:
+                    throw new Error(`Invalid array condition: ${JSON.stringify(set)}`);
             }
-
-            if (value.length === 2 && OPERATORS.includes(value[0])) {
-                parts.push(addCondition(key, value[0], value[1]));
-            } else if (value.length === 1 && isAggregateArray(value[0])) {
-                parts.push(addCondition(key, '=', value[0]));
-            } else {
-                throw new Error(`Invalid condition for ${key}: ${JSON.stringify(value)}`);
+        } else {
+            const parts: string[] = [];
+            for (const [key, value] of Object.entries(set)) {
+                if (/^\d+$/.test(key)) {
+                    parts.push(this.buildBooleanJoinedConditions(value, !andMode, params));
+                } else if (!Array.isArray(value) || isAggregateArray(value)) {
+                    parts.push(addCondition(key, '=', value));
+                } else if (value.length === 2 && OPERATORS.includes(value[0])) {
+                    parts.push(addCondition(key, value[0], value[1]));
+                } else {
+                    throw new Error(`Invalid condition for ${key}: ${JSON.stringify(value)}`);
+                }
             }
+            sql = parts.join(` ${booleanOperator} `);
         }
 
-        sql = parts.join(` ${booleanOperator} `);
+        isVerbose() && console.log(`[WHERE] Final: (${sql})`);
+        return `(${sql})`;
     }
 
-    return `(${sql})`;
-}
+    /** Translate array or function calls into SQL expressions */
+    protected buildAggregateField(field: string | any[]): string {
+        if (typeof field === 'string') return field;
+        if (!Array.isArray(field)) throw new Error('Invalid SELECT entry');
 
-export function  buildAggregateField(field: string | any[]): string {
-    if (typeof field === 'string') return field;
-
-    if (!Array.isArray(field)) throw new Error('Invalid SELECT entry: must be string or array');
-
-    const [agg, ...args] = field;
-
-    switch (agg) {
-        case 'COUNT':
-            return `COUNT(${args[0] || '*'})`;
-        case 'SUM':
-        case 'AVG':
-        case 'MIN':
-        case 'MAX':
-            return `${agg}(${args[0]})${args[1] ? ` AS ${args[1]}` : ''}`;
-        case 'DISTINCT':
-            return `DISTINCT(${args[0]})${args[1] ? ` AS ${args[1]}` : ''}`;
-        case 'GROUP_CONCAT': {
-            const [col, alias, sortCol, sortType] = args;
-            const order = sortCol ? ` ORDER BY ${sortCol} ${sortType || 'ASC'}` : '';
-            return `GROUP_CONCAT(DISTINCT ${col}${order} SEPARATOR ',')${alias ? ` AS ${alias}` : ''}`;
-        }
-        case 'AS': {
-            const [col, alias] = args;
-            return `${col} AS ${alias}`;
+        let [fn, ...args] = field;
+        let alias: string | undefined;
+        if (args.length >= 2 && args[args.length - 2] === 'AS') {
+            alias = String(args.pop());
+            args.pop();
         }
-        case 'CONVERT_TZ': {
-            const [ts, fromTz, toTz] = args;
-            return `CONVERT_TZ(${ts}, ${fromTz}, ${toTz})`;
+        const F = String(fn).toUpperCase();
+        const p = args.join(', ');
+
+        isVerbose() && console.log(`[SELECT] ${F}(${p})${alias ? ` AS ${alias}` : ''}`);
+        switch (F) {
+            case 'DATE_ADD':
+                return `DATE_ADD(${args[0]}, ${args[1]})${alias ? ` AS ${alias}` : ''}`;
+            case 'DATE_SUB':
+                return `DATE_SUB(${args[0]}, ${args[1]})${alias ? ` AS ${alias}` : ''}`;
+            case 'YEAR':
+                return `YEAR(${args[0]})${alias ? ` AS ${alias}` : ''}`;
+            case 'MONTH':
+                return `MONTH(${args[0]})${alias ? ` AS ${alias}` : ''}`;
+            case 'DAY':
+                return `DAY(${args[0]})${alias ? ` AS ${alias}` : ''}`;
+            case 'ROUND':
+            case 'CEIL':
+            case 'FLOOR':
+            case 'ABS':
+            case 'SQRT':
+                return `${F}(${p})${alias ? ` AS ${alias}` : ''}`;
+            case 'ST_DISTANCE':
+                return `ST_Distance(${p})${alias ? ` AS ${alias}` : ''}`;
+            default:
+                if (/^[A-Z_]+$/.test(F)) return `${F}(${p})${alias ? ` AS ${alias}` : ''}`;
+                throw new Error(`Unsupported function: ${F}`);
         }
-        case 'NOW':
-            return 'NOW()';
-        default:
-            throw new Error(`Unsupported aggregate: ${agg}`);
     }
-}
 
-export function  buildSelectQuery<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any, isSubSelect = false): string {
-    const selectList = args?.[C6Constants.SELECT] ?? ['*'];
-    const selectFields = Array.isArray(selectList)
-        ? selectList.map(f => buildAggregateField(f)).join(', ')
-        : '*';
-
-    let sql = `SELECT ${selectFields} FROM \`${table}\``;
-
-    if (args?.[C6Constants.JOIN]) {
-        const joins = args[C6Constants.JOIN];
-        for (const joinType in joins) {
-            const joinKeyword = joinType.replace('_', ' ').toUpperCase();
-            for (const joinTable in joins[joinType]) {
-                const onClause = buildBooleanJoinedConditions(joins[joinType][joinTable]);
-                sql += ` ${joinKeyword} JOIN \`${joinTable}\` ON ${onClause}`;
+    /** Compose a parameterized SELECT query with optional JOIN/WHERE/GROUP/HAVING/PAGINATION */
+    protected buildSelectQuery<RestShortTableNames>(
+        table: RestShortTableNames,
+        primary: string | undefined,
+        args: any,
+        isSubSelect = false
+    ): QueryResult {
+        const model = this.config.C6.TABLES[table as string];
+        const params: any[] = [];
+
+        // SELECT
+        const selectList = args?.[C6Constants.SELECT] ?? ['*'];
+        const selectFields = Array.isArray(selectList)
+            ? selectList.map(f => this.buildAggregateField(f)).join(', ')
+            : '*';
+        let sql = `SELECT ${selectFields} FROM ${table}`;
+        isVerbose() && console.log(`[SELECT]`, selectFields);
+
+        // JOIN
+        if (args?.[C6Constants.JOIN]) {
+            for (const jt in args[C6Constants.JOIN]) {
+                const jk = jt.replace('_', ' ').toUpperCase();
+                for (const jn in args[C6Constants.JOIN][jt]) {
+                    const on = this.buildBooleanJoinedConditions(args[C6Constants.JOIN][jt][jn], true, params);
+                    sql += ` ${jk} JOIN \`${jn}\` ON ${on}`;
+                    isVerbose() && console.log(`[JOIN]`, jk, jn, on);
+                }
             }
         }
-    }
 
-    if (args?.[C6Constants.WHERE]) {
-        sql += ` WHERE ${buildBooleanJoinedConditions(args[C6Constants.WHERE])}`;
-    }
-
-    if (args?.[C6Constants.GROUP_BY]) {
-        const groupByFields = Array.isArray(args[C6Constants.GROUP_BY]) ? args[C6Constants.GROUP_BY].join(', ') : args[C6Constants.GROUP_BY];
-        sql += ` GROUP BY ${groupByFields}`;
-    }
+        // WHERE
+        if (args?.[C6Constants.WHERE]) {
+            let wc = this.buildBooleanJoinedConditions(args[C6Constants.WHERE], true, params);
+            // Trim leading and trailing parentheses if they fully wrap the condition
+            while (wc.startsWith('(') && wc.endsWith(')')) {
+                wc = wc.slice(1, -1).trim();
+            }
+            sql += ` WHERE ${wc}`;
+        }
 
-    if (args?.[C6Constants.HAVING]) {
-        sql += ` HAVING ${buildBooleanJoinedConditions(args[C6Constants.HAVING])}`;
-    }
+        // GROUP BY
+        if (args?.[C6Constants.GROUP_BY]) {
+            const gb = Array.isArray(args[C6Constants.GROUP_BY])
+                ? args[C6Constants.GROUP_BY].join(', ')
+                : args[C6Constants.GROUP_BY];
+            sql += ` GROUP BY ${gb}`;
+            isVerbose() && console.log(`[GROUP BY]`, gb);
+        }
 
-    if (args?.[C6Constants.PAGINATION]) {
-        const p = args[C6Constants.PAGINATION];
-        let limitClause = '';
+        // HAVING
+        if (args?.[C6Constants.HAVING]) {
+            const hc = this.buildBooleanJoinedConditions(args[C6Constants.HAVING], true, params);
+            sql += ` HAVING ${hc}`;
+        }
 
-        if (p[C6Constants.ORDER]) {
-            const orderArray = Object.entries(p[C6Constants.ORDER]).map(([col, dir]) => {
-                if (!['ASC', 'DESC'].includes(String(dir).toUpperCase())) {
-                    throw new Error(`Invalid order direction: ${dir}`);
-                }
-                return `${col} ${String(dir).toUpperCase()}`;
-            });
-            sql += ` ORDER BY ${orderArray.join(', ')}`;
-        } else if (primary) {
-            sql += ` ORDER BY ${primary} DESC`;
-        } /*else {
-            // todo - this is wrong
-            const primaryKey = C6Constants.TABLES['users'].PRIMARY_SHORT?.[0] ?? 'user_id';
-            sql += ` ORDER BY ${primaryKey} DESC`;
-        }*/
-
-        if (p[C6Constants.LIMIT] != null) {
-            const limit = parseInt(p[C6Constants.LIMIT], 10);
-            if (isNaN(limit) || limit < 0) {
-                throw new Error(`Invalid LIMIT: ${p[C6Constants.LIMIT]}`);
+        // PAGINATION
+        if (args?.[C6Constants.PAGINATION]) {
+            const p = args[C6Constants.PAGINATION];
+            if (p[C6Constants.ORDER]) {
+                const ord = Object.entries(p[C6Constants.ORDER]).map(([c, d]) => `${c} ${String(d).toUpperCase()}`);
+                sql += ` ORDER BY ${ord.join(', ')}`;
+                isVerbose() && console.log(`[ORDER BY]`, ord);
             }
-
-            const page = parseInt(p[C6Constants.PAGE] ?? 1, 10);
-            if (isNaN(page) || page < 1) {
-                throw new Error(`PAGE must be >= 1 (got ${p[C6Constants.PAGE]})`);
+            if (p[C6Constants.LIMIT] != null) {
+                const lim = parseInt(p[C6Constants.LIMIT], 10);
+                const pg = parseInt(p[C6Constants.PAGE] ?? 1, 10);
+                const off = (pg - 1) * lim;
+                sql += ` LIMIT ${off}, ${lim}`;
+                isVerbose() && console.log(`[LIMIT]`, off, lim);
+            }
+        }
+        // Fallback ORDER/LIMIT
+        else if (!isSubSelect) {
+            let ok: string | undefined;
+            if (primary) ok = primary;
+            else if (model?.PRIMARY_SHORT?.[0]) ok = model.PRIMARY_SHORT[0];
+            else for (const ts of ['created_at', 'updated_at']) {
+                    if (model?.COLUMNS?.[`${table}.${ts}`]) {
+                        ok = ts;
+                        break;
+                    }
+                }
+            if (ok) {
+                const dir = primary ? 'ASC' : 'DESC';
+                const lim = primary ? 1 : 100;
+                sql += ` ORDER BY ${ok} ${dir} LIMIT ${lim}`;
+                isVerbose() && console.log(`[ORDER]`, ok, dir, lim);
+            } else {
+                sql += ` LIMIT 100`;
+                isVerbose() && console.warn(`[ORDER] fallback LIMIT 100`);
             }
-
-            const offset = (page - 1) * limit;
-            limitClause += ` LIMIT ${offset}, ${limit}`;
         }
 
-        sql += limitClause;
-    } else if (!isSubSelect && primary) {
-        sql += ` ORDER BY ${primary} ASC LIMIT 1`;
-    } else if (!isSubSelect && !primary) {
-        sql += ` ORDER BY id ASC LIMIT 100`; // fallback default limit
+        isVerbose() && console.log(`[SQL]`, sql, params);
+        return {sql, params};
     }
-
-    return sql;
 }

package/src/api/executors/Executor.ts

@@ -5,7 +5,7 @@ import {
     iRestMethods,
     iRestReactiveLifecycle,
     RequestQueryBody
-} from "@carbonorm/carbonnode";
+} from "../types/ormInterfaces";
 import isVerbose from "../../variables/isVerbose";
 
 export abstract class Executor<
@@ -60,7 +60,7 @@ export abstract class Executor<
 
         for (const [key, fn] of Object.entries(lifecycleGroup)) {
             if (typeof fn === "function") {
-                if (isVerbose || (args.request as any).debug) {
+                if (isVerbose() || (args.request as any).debug) {
                     console.groupCollapsed(`[LIFECYCLE] ${this.config.requestMethod}.${String(phase)}:${key}`);
                     console.log("config:", args.config);
                     console.log("request:", args.request);

package/src/api/executors/HttpExecutor.ts

@@ -303,7 +303,7 @@ export class HttpExecutor<
 
                         } while (undefined !== cacheResult)
 
-                        if (debug && isLocal) {
+                        if (debug && isLocal()) {
 
                             toast.warning("DEVS: Request in cache. (" + apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized) + "). Returning function to request page (" + query[C6.PAGINATION][C6.PAGE] + ")", toastOptionsDevs);
 
@@ -318,7 +318,7 @@ export class HttpExecutor<
 
                 } else {
 
-                    if (debug && isLocal) {
+                    if (debug && isLocal()) {
 
                         toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
 
@@ -326,7 +326,7 @@ export class HttpExecutor<
 
                 }
 
-                if (debug && isLocal) {
+                if (debug && isLocal()) {
 
                     toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? "Page (" + query[C6.PAGINATION][C6.PAGE] + ")." : '') + " Logging cache 2 console.", toastOptionsDevs);
 
@@ -390,7 +390,7 @@ export class HttpExecutor<
                         || null === query
                         || false === primaryKey in query) {
 
-                        if (true === debug && isLocal) {
+                        if (true === debug && isLocal()) {
 
                             toast.error('DEVS: The primary key (' + primaryKey + ') was not provided!!')
 
@@ -538,7 +538,7 @@ export class HttpExecutor<
                         // noinspection SuspiciousTypeOfGuard
                         if (typeof response.data === 'string') {
 
-                            if (isTest) {
+                            if (isTest()) {
 
                                 console.trace()
 
@@ -575,7 +575,7 @@ export class HttpExecutor<
 
 
 
-                            if (debug && isLocal) {
+                            if (debug && isLocal()) {
 
                                 toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
 
@@ -624,7 +624,7 @@ export class HttpExecutor<
                             returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
                                 query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length
 
-                            if (false === isTest || true === isVerbose) {
+                            if (false === isTest() || true === isVerbose()) {
 
                                 console.groupCollapsed('%c API: Response (' + requestMethod + ' ' + tableName + ') returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', 'color: #0c0')
 
@@ -644,7 +644,7 @@ export class HttpExecutor<
 
                             if (false === returnGetNextPageFunction
                                 && true === debug
-                                && isLocal) {
+                                && isLocal()) {
 
                                 toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
 
@@ -889,7 +889,7 @@ export class HttpExecutor<
 
                         }
 
-                        if (debug && isLocal) {
+                        if (debug && isLocal()) {
 
                             toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
 
@@ -902,7 +902,7 @@ export class HttpExecutor<
 
             } catch (throwableError) {
 
-                if (isTest) {
+                if (isTest()) {
 
                     throw new Error(JSON.stringify(throwableError))
 

package/src/api/executors/SqlExecutor.ts

@@ -1,3 +1,4 @@
+import { SqlBuilder } from "api/builders/sqlBuilder";
 import {
     apiReturn,
     DetermineResponseDataType,
@@ -5,10 +6,8 @@ import {
     iPutC6RestResponse,
     iDeleteC6RestResponse,
     iRestMethods
-} from "@carbonorm/carbonnode";
+} from "../types/ormInterfaces";
 import { PoolConnection, RowDataPacket, ResultSetHeader } from 'mysql2/promise';
-import { buildSelectQuery } from "../builders/sqlBuilder";
-import { Executor } from "./Executor";
 
 export class SqlExecutor<
     RequestMethod extends iRestMethods,
@@ -16,8 +15,8 @@ export class SqlExecutor<
     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 Executor<
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+> extends SqlBuilder<
     RequestMethod,
     RestShortTableName,
     RestTableInterface,
@@ -25,48 +24,76 @@ export class SqlExecutor<
     CustomAndRequiredFields,
     RequestTableOverrides
 > {
+
     async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
-        const { TABLE_NAME, PRIMARY } = this.config.restModel;
+        const { TABLE_NAME } = this.config.restModel;
+        const method = this.config.requestMethod;
+
+        console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
+        console.log(`[SQL EXECUTOR] 🧾 Request payload:`, this.request);
 
-        switch (this.config.requestMethod) {
+        switch (method) {
             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>>;
             }
+
             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>>;
             }
+
             case 'PUT': {
-                const result = await this.update(TABLE_NAME, PRIMARY, this.request);
-                const updated: iPutC6RestResponse = { rest: result, updated: true, rowCount: (result as ResultSetHeader).affectedRows };
+                const result = await this.update(TABLE_NAME, [], this.request);
+                console.log(`[SQL EXECUTOR] ✅ PUT result:`, result);
+                const updated: iPutC6RestResponse = {
+                    rest: result,
+                    updated: true,
+                    rowCount: (result as ResultSetHeader).affectedRows
+                };
                 return updated as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
             }
+
             case 'DELETE': {
-                const result = await this.delete(TABLE_NAME, PRIMARY, this.request);
-                const deleted: iDeleteC6RestResponse = { rest: result, deleted: true, rowCount: (result as ResultSetHeader).affectedRows };
+                const result = await this.delete(TABLE_NAME, [], this.request);
+                console.log(`[SQL EXECUTOR] ✅ DELETE result:`, result);
+                const deleted: iDeleteC6RestResponse = {
+                    rest: result,
+                    deleted: true,
+                    rowCount: (result as ResultSetHeader).affectedRows
+                };
                 return deleted as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
             }
+
             default:
-                throw new Error(`Unsupported request method: ${this.config.requestMethod}`);
+                throw new Error(`Unsupported request method: ${method}`);
         }
     }
 
     private async withConnection<T>(cb: (conn: PoolConnection) => Promise<T>): Promise<T> {
+        console.log(`[SQL EXECUTOR] 📡 Getting DB connection`);
         const conn = await this.config.mysqlPool!.getConnection();
         try {
+            console.log(`[SQL EXECUTOR] ✅ Connection acquired`);
             return await cb(conn);
         } finally {
+            console.log(`[SQL EXECUTOR] 🔌 Releasing DB connection`);
             conn.release();
         }
     }
 
     async select<TName extends string>(table: TName, primary: string | undefined, args: any) {
-        const sql = buildSelectQuery<TName>(table, primary, args);
+        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);
+
         return await this.withConnection(async (conn) => {
-            console.log(sql);
-            const [rows] = await conn.query<RowDataPacket[]>(sql);
+            const [rows] = await conn.query<RowDataPacket[]>(sql.sql, sql.params);
+            console.log(`[SQL EXECUTOR] 📦 Rows fetched:`, rows);
             return rows;
         });
     }
@@ -76,6 +103,10 @@ export class SqlExecutor<
         const values = keys.map(k => data[k]);
         const placeholders = keys.map(() => '?').join(', ');
         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;
@@ -89,6 +120,10 @@ export class SqlExecutor<
         const updates = keys.map(k => `\`${k}\` = ?`).join(', ');
         const sql = `UPDATE \`${table}\` SET ${updates} WHERE \`${primary[0]}\` = ?`;
         values.push(data[primary[0]]);
+
+        console.log(`[SQL EXECUTOR] 🧠 Generated UPDATE SQL:`, sql);
+        console.log(`[SQL EXECUTOR] 🔢 Values:`, values);
+
         return await this.withConnection(async (conn) => {
             const [result] = await conn.execute<ResultSetHeader>(sql, values);
             return result;
@@ -99,9 +134,30 @@ export class SqlExecutor<
         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}\` = ?`;
+
+        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;
         });
     }
+
+
+    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)}'`;
+        });
+    }
+
 }

package/src/api/restRequest.ts

@@ -37,7 +37,7 @@ export default function restRequest<
         const config = typeof configX === "function" ? configX() : configX;
 
         // SQL path if on Node with a provided pool
-        if (isNode && config.mysqlPool) {
+        if (isNode() && config.mysqlPool) {
             const {SqlExecutor} = await import('./executors/SqlExecutor');
             const executor = new SqlExecutor<
                 RequestMethod,