@carbonorm/carbonnode 3.0.13 → 3.0.15

package/src/api/executors/SqlExecutor.ts

@@ -1,4 +1,4 @@
-import { SqlBuilder } from "api/builders/sqlBuilder";
+import {SqlBuilder} from "api/builders/sqlBuilder";
 import {
     apiReturn,
     DetermineResponseDataType,
@@ -7,7 +7,9 @@ import {
     iDeleteC6RestResponse,
     iRestMethods
 } 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';
 
 export class SqlExecutor<
     RequestMethod extends iRestMethods,
@@ -25,8 +27,9 @@ export class SqlExecutor<
     RequestTableOverrides
 > {
 
+
     async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
-        const { TABLE_NAME } = this.config.restModel;
+        const {TABLE_NAME} = this.config.restModel;
         const method = this.config.requestMethod;
 
         console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
@@ -36,13 +39,13 @@ 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<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 };
+                const created: iPostC6RestResponse = {rest: result, created: true};
                 return created as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
             }
 
@@ -50,9 +53,9 @@ export class SqlExecutor<
                 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>>;
             }
@@ -63,7 +66,7 @@ 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>>;
             }
@@ -85,16 +88,26 @@ export class SqlExecutor<
         }
     }
 
+    public serialize = (row: any) => Object.fromEntries(Object.entries(row).map(
+        ([k, v]) => [k, Buffer.isBuffer(v) ? v.toString('hex').toUpperCase() : v]
+    ));
+
     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);
+        const QueryResult = this.buildSelectQuery<TName>(table, primary, args);
+        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
+                }
+            };
         });
     }
 
@@ -102,14 +115,20 @@ export class SqlExecutor<
         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
+                }
+            };
         });
     }
 
@@ -118,7 +137,9 @@ export class SqlExecutor<
         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 +147,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>) {
         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});
             next(err);
         }
     };

package/src/api/types/ormInterfaces.ts

@@ -238,10 +238,10 @@ export interface iRestApiFunctions<RestData extends { [key: string]: any } = any
     Put: (request?: RequestQueryBody<'PUT', RestData>) => apiReturn<iPutC6RestResponse<RestData>>;
 }
 
-export interface iC6Object<
-    RestShortTableName extends string = any,
-    RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
+    export interface iC6Object<
+        RestShortTableName extends string = any,
+        RestTableInterface extends { [key: string]: any } = any,
+        PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
 > {
     C6VERSION: string;
     TABLES: {