@carbonorm/carbonnode 6.0.7 → 6.0.9

package/src/executors/SqlExecutor.ts

@@ -14,6 +14,7 @@ import { Buffer } from 'buffer';
 import { Executor } from "./Executor";
 import { normalizeSingularRequest } from "../utils/normalizeSingularRequest";
 import { loadSqlAllowList, normalizeSql } from "../utils/sqlAllowList";
+import { getLogContext, LogLevel, logWithLevel } from "../utils/logLevel";
 
 export class SqlExecutor<
     G extends OrmGenerics
@@ -36,8 +37,20 @@ export class SqlExecutor<
             throw e;
         }
 
-        this.config.verbose && console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
-        this.config.verbose && console.log(`[SQL EXECUTOR] 🧩 Request:`, this.request);
+        const logContext = getLogContext(this.config, this.request);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            `[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`,
+        );
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            `[SQL EXECUTOR] 🧩 Request:`,
+            this.request,
+        );
 
         switch (method) {
             case 'GET': {
@@ -76,13 +89,29 @@ export class SqlExecutor<
     }
 
     private async withConnection<T>(cb: (conn: PoolConnection) => Promise<T>): Promise<T> {
-        this.config.verbose && console.log(`[SQL EXECUTOR] 📡 Getting DB connection`);
+        const logContext = getLogContext(this.config, this.request);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            `[SQL EXECUTOR] 📡 Getting DB connection`,
+        );
         const conn = await this.config.mysqlPool!.getConnection();
         try {
-            this.config.verbose && console.log(`[SQL EXECUTOR] ✅ Connection acquired`);
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                `[SQL EXECUTOR] ✅ Connection acquired`,
+            );
             return await cb(conn);
         } finally {
-            this.config.verbose && console.log(`[SQL EXECUTOR] 🔌 Releasing DB connection`);
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                `[SQL EXECUTOR] 🔌 Releasing DB connection`,
+            );
             conn.release();
         }
     }
@@ -267,14 +296,27 @@ export class SqlExecutor<
         response?: DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>
     ): Promise<void> {
         const broadcast = this.config.websocketBroadcast;
-        this.config.verbose && console.log("[SQL EXECUTOR] 📣 broadcastWebsocketIfConfigured start", {
-            method: this.config.requestMethod,
-            hasBroadcast: Boolean(broadcast),
-        });
+        const logContext = getLogContext(this.config, this.request);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            "[SQL EXECUTOR] 📣 broadcastWebsocketIfConfigured start",
+            {
+                method: this.config.requestMethod,
+                hasBroadcast: Boolean(broadcast),
+            },
+        );
         if (!broadcast || this.config.requestMethod === C6C.GET) {
-            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast skipped", {
-                reason: !broadcast ? "no broadcast configured" : "GET request",
-            });
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                "[SQL EXECUTOR] 📣 websocket broadcast skipped",
+                {
+                    reason: !broadcast ? "no broadcast configured" : "GET request",
+                },
+            );
             return;
         }
 
@@ -285,27 +327,51 @@ export class SqlExecutor<
         let responseRest = response?.rest;
         let responsePrimaryKey = this.extractPrimaryKeyValuesFromData(responseRest);
 
-        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket request payload", {
-            normalizedRequest,
-            requestPrimaryKey: this.extractPrimaryKeyValues(),
-            pkShorts,
-        });
-        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket response payload", {
-            responseRest,
-            responsePrimaryKey,
-        });
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            "[SQL EXECUTOR] 📣 websocket request payload",
+            {
+                normalizedRequest,
+                requestPrimaryKey: this.extractPrimaryKeyValues(),
+                pkShorts,
+            },
+        );
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            "[SQL EXECUTOR] 📣 websocket response payload",
+            {
+                responseRest,
+                responsePrimaryKey,
+            },
+        );
 
         if (
             (responseRest === null || (Array.isArray(responseRest) && responseRest.length === 0))
             && this.config.requestMethod === C6C.POST
         ) {
-            this.config.verbose && console.log("[SQL EXECUTOR] 📣 response rest empty, attempting synthesize", {
-                responseRest,
-            });
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                "[SQL EXECUTOR] 📣 response rest empty, attempting synthesize",
+                {
+                    responseRest,
+                },
+            );
             const insertId = (response as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']> & { insertId?: number | string | null })?.insertId;
-            this.config.verbose && console.log("[SQL EXECUTOR] 📣 POST insertId lookup", {
-                insertId,
-            });
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                "[SQL EXECUTOR] 📣 POST insertId lookup",
+                {
+                    insertId,
+                },
+            );
             if (insertId !== undefined && pkShorts.length === 1) {
                 const synthesizedRequest = {
                     ...normalizedRequest,
@@ -330,10 +396,16 @@ export class SqlExecutor<
                 responsePrimaryKey = {
                     [pkShorts[0]]: insertId,
                 };
-                this.config.verbose && console.log("[SQL EXECUTOR] 📣 synthesized response payload", {
-                    synthesized,
-                    responsePrimaryKey,
-                });
+                logWithLevel(
+                    LogLevel.DEBUG,
+                    logContext,
+                    console.log,
+                    "[SQL EXECUTOR] 📣 synthesized response payload",
+                    {
+                        synthesized,
+                        responsePrimaryKey,
+                    },
+                );
             }
         }
 
@@ -349,16 +421,36 @@ export class SqlExecutor<
             },
         };
 
-        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket payload ready", payload);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            "[SQL EXECUTOR] 📣 websocket payload ready",
+            payload,
+        );
 
         try {
-            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch start");
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                "[SQL EXECUTOR] 📣 websocket broadcast dispatch start",
+            );
             await broadcast(payload);
-            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch complete");
+            logWithLevel(
+                LogLevel.DEBUG,
+                logContext,
+                console.log,
+                "[SQL EXECUTOR] 📣 websocket broadcast dispatch complete",
+            );
         } catch (error) {
-            if (this.config.verbose) {
-                console.error("[SQL EXECUTOR] websocketBroadcast failed", error);
-            }
+            logWithLevel(
+                LogLevel.ERROR,
+                logContext,
+                console.error,
+                "[SQL EXECUTOR] websocketBroadcast failed",
+                error,
+            );
         }
     }
     async runQuery(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>> {
@@ -385,10 +477,23 @@ export class SqlExecutor<
 
         const QueryResult = builder.build(TABLE_NAME);
 
-        this.config.verbose && console.log(`[SQL EXECUTOR] 🧠 Generated ${method.toUpperCase()} SQL:`, QueryResult);
+        const logContext = getLogContext(this.config, this.request);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            `[SQL EXECUTOR] 🧠 Generated ${method.toUpperCase()} SQL:`,
+            QueryResult,
+        );
 
         const formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
-        this.config.verbose && console.log(`[SQL EXECUTOR] 🧠 Formatted ${method.toUpperCase()} SQL:`, formatted);
+        logWithLevel(
+            LogLevel.DEBUG,
+            logContext,
+            console.log,
+            `[SQL EXECUTOR] 🧠 Formatted ${method.toUpperCase()} SQL:`,
+            formatted,
+        );
 
         const toUnnamed = namedPlaceholders();
         const [sql, values] = toUnnamed(QueryResult.sql, QueryResult.params);
@@ -404,7 +509,13 @@ export class SqlExecutor<
                     sql: { sql, values }
                 } as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             } else {
-                this.config.verbose && console.log(`[SQL EXECUTOR] ✏️ Rows affected:`, result.affectedRows);
+                logWithLevel(
+                    LogLevel.DEBUG,
+                    logContext,
+                    console.log,
+                    `[SQL EXECUTOR] ✏️ Rows affected:`,
+                    result.affectedRows,
+                );
                 return {
                     affected: result.affectedRows as number,
                     insertId: result.insertId as number,

package/src/handlers/ExpressHandler.ts

@@ -3,6 +3,7 @@ import type {Pool} from "mysql2/promise";
 import {C6C} from "../constants/C6Constants";
 import restRequest from "../api/restRequest";
 import type {iC6Object, iRestMethods, tWebsocketBroadcast} from "../types/ormInterfaces";
+import {LogLevel, logWithLevel} from "../utils/logLevel";
 
 
 // TODO - WE MUST make this a generic - optional, but helpful
@@ -40,7 +41,12 @@ export function ExpressHandler({
 
             // Warn for unsupported overrides but continue normally
             if (incomingMethod !== 'GET' && methodOverride && methodOverride !== 'GET') {
-                console.warn(`Ignoring unsupported METHOD override: ${methodOverride}`);
+                logWithLevel(
+                    LogLevel.WARN,
+                    undefined,
+                    console.warn,
+                    `Ignoring unsupported METHOD override: ${methodOverride}`,
+                );
             }
 
             if (!(table in C6.TABLES)) {

package/src/index.ts

@@ -36,6 +36,9 @@ export * from "./utils/cacheManager";
 export { default as colorSql } from "./utils/colorSql";
 export * from "./utils/colorSql";
 export * from "./utils/determineRuntimeJsType";
+export * from "./utils/logLevel";
+export { default as logSql } from "./utils/logSql";
+export * from "./utils/logSql";
 export * from "./utils/logger";
 export * from "./utils/normalizeSingularRequest";
 export * from "./utils/sortAndSerializeQueryObject";
@@ -43,6 +46,8 @@ export * from "./utils/sqlAllowList";
 export * from "./utils/testHelpers";
 export * from "./utils/toastNotifier";
 export * from "./utils/toastRuntime";
+export { default as versionColor } from "./utils/versionColor";
+export * from "./utils/versionColor";
 export * from "./variables/getEnv";
 export { default as isLocal } from "./variables/isLocal";
 export * from "./variables/isLocal";

package/src/orm/builders/AggregateBuilder.ts

@@ -1,6 +1,7 @@
 import {Executor} from "../../executors/Executor";
 import {OrmGenerics} from "../../types/ormGenerics";
 import {C6C} from "../../constants/C6Constants";
+import {getLogContext, LogLevel, logWithLevel} from "../../utils/logLevel";
 
 export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G>{
     protected selectAliases: Set<string> = new Set<string>();
@@ -76,7 +77,12 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
                 expr += ` AS ${alias}`;
             }
 
-            this.config.verbose && console.log(`[SELECT] ${expr}`);
+            logWithLevel(
+                LogLevel.DEBUG,
+                getLogContext(this.config, this.request),
+                console.log,
+                `[SELECT] ${expr}`,
+            );
 
             return expr;
         }
@@ -123,7 +129,12 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
             expr += ` AS ${alias}`;
         }
 
-        this.config.verbose && console.log(`[SELECT] ${expr}`);
+        logWithLevel(
+            LogLevel.DEBUG,
+            getLogContext(this.config, this.request),
+            console.log,
+            `[SELECT] ${expr}`,
+        );
 
         return expr;
     }

package/src/orm/builders/ConditionBuilder.ts

@@ -4,6 +4,7 @@ import {DetermineResponseDataType} from "../../types/ormInterfaces";
 import {convertHexIfBinary, SqlBuilderResult} from "../utils/sqlUtils";
 import {AggregateBuilder} from "./AggregateBuilder";
 import {isDerivedTableKey} from "../queryHelpers";
+import {getLogContext, LogLevel, logWithLevel} from "../../utils/logLevel";
 
 export abstract class ConditionBuilder<
     G extends OrmGenerics
@@ -639,7 +640,12 @@ export abstract class ConditionBuilder<
             }
 
             const clause = `(MATCH(${leftInfo.sql}) ${againstClause})`;
-            this.config.verbose && console.log(`[MATCH_AGAINST] ${clause}`);
+            logWithLevel(
+                LogLevel.DEBUG,
+                getLogContext(this.config, this.request),
+                console.log,
+                `[MATCH_AGAINST] ${clause}`,
+            );
             return clause;
         }
 
@@ -914,7 +920,12 @@ export abstract class ConditionBuilder<
             }
         }
 
-        this.config.verbose && console.log(`[WHERE] ${trimmed}`);
+        logWithLevel(
+            LogLevel.DEBUG,
+            getLogContext(this.config, this.request),
+            console.log,
+            `[WHERE] ${trimmed}`,
+        );
         return ` WHERE ${trimmed}`;
     }
 }

package/src/orm/builders/JoinBuilder.ts

@@ -2,6 +2,7 @@ import {OrmGenerics} from "../../types/ormGenerics";
 import {ConditionBuilder} from "./ConditionBuilder";
 import {C6C} from "../../constants/C6Constants";
 import {resolveDerivedTable, isDerivedTableKey} from "../queryHelpers";
+import {getLogContext, LogLevel, logWithLevel} from "../../utils/logLevel";
 
 export abstract class JoinBuilder<G extends OrmGenerics> extends ConditionBuilder<G>{
 
@@ -238,7 +239,12 @@ export abstract class JoinBuilder<G extends OrmGenerics> extends ConditionBuilde
             }
         }
 
-        this.config.verbose && console.log(`[JOIN] ${sql.trim()}`);
+        logWithLevel(
+            LogLevel.DEBUG,
+            getLogContext(this.config, this.request),
+            console.log,
+            `[JOIN] ${sql.trim()}`,
+        );
 
         return sql;
     }

package/src/orm/builders/PaginationBuilder.ts

@@ -1,6 +1,7 @@
 import {C6Constants} from "../../constants/C6Constants";
 import {OrmGenerics} from "../../types/ormGenerics";
 import {JoinBuilder} from "./JoinBuilder";
+import {getLogContext, LogLevel, logWithLevel} from "../../utils/logLevel";
 
 export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
 
@@ -72,7 +73,12 @@ export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuild
             }
         }
 
-        this.config.verbose && console.log(`[PAGINATION] ${sql.trim()}`);
+        logWithLevel(
+            LogLevel.DEBUG,
+            getLogContext(this.config, this.request),
+            console.log,
+            `[PAGINATION] ${sql.trim()}`,
+        );
         return sql;
     }
 }

package/src/orm/queries/DeleteQueryBuilder.ts

@@ -2,6 +2,8 @@ import { OrmGenerics } from "../../types/ormGenerics";
 import { SqlBuilderResult } from "../utils/sqlUtils";
 import { JoinBuilder } from "../builders/JoinBuilder";
 import { SelectQueryBuilder } from "./SelectQueryBuilder";
+import logSql from "../../utils/logSql";
+import {getLogContext} from "../../utils/logLevel";
 
 export class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
     protected createSelectBuilder(request: any) {
@@ -25,6 +27,8 @@ export class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
             sql += this.buildWhereClause(this.request.WHERE, params);
         }
 
+        logSql("DELETE", sql, getLogContext(this.config, this.request));
+
         return { sql, params };
     }
 }

package/src/orm/queries/PostQueryBuilder.ts

@@ -1,6 +1,8 @@
 import {C6C} from "../../constants/C6Constants";
 import {ConditionBuilder} from "../builders/ConditionBuilder";
 import {OrmGenerics} from "../../types/ormGenerics";
+import logSql from "../../utils/logSql";
+import {getLogContext} from "../../utils/logLevel";
 
 export class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G>{
 
@@ -47,6 +49,8 @@ export class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G>
             sql += ` ON DUPLICATE KEY UPDATE ${updateClause}`;
         }
 
+        logSql(verb, sql, getLogContext(this.config, this.request));
+
         return {sql, params};
     }
 }

package/src/orm/queries/SelectQueryBuilder.ts

@@ -1,17 +1,8 @@
 import {OrmGenerics} from "../../types/ormGenerics";
 import {PaginationBuilder} from "../builders/PaginationBuilder";
 import {SqlBuilderResult} from "../utils/sqlUtils";
-import {getEnvBool} from "../../variables/getEnv";
-import colorSql from "../../utils/colorSql";
-import { version } from "../../../package.json";
-
-
-const C = {
-    SSR: "\x1b[95m",     // bright magenta
-    HTTP: "\x1b[94m",    // bright blue
-    SQL: "\x1b[96m",     // bright cyan (your SELECT teal)
-    RESET: "\x1b[0m",
-};
+import logSql from "../../utils/logSql";
+import {getLogContext} from "../../utils/logLevel";
 
 export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
 
@@ -67,9 +58,7 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             sql += ` LIMIT 100`;
         }
 
-        const preText = getEnvBool("SSR", false) ? `${C.SSR}[SSR]${C.RESET} ` : `${C.HTTP}[API]${C.RESET} `;
-
-        console.log(`[${version}] ${preText}${C.SQL}[SELECT]${C.RESET} ${colorSql(sql)}`);
+        logSql("SELECT", sql, getLogContext(this.config, this.request));
 
         return { sql, params };
     }

package/src/orm/queries/UpdateQueryBuilder.ts

@@ -3,6 +3,8 @@ import {OrmGenerics} from "../../types/ormGenerics";
 import { PaginationBuilder } from '../builders/PaginationBuilder';
 import {SqlBuilderResult} from "../utils/sqlUtils";
 import {SelectQueryBuilder} from "./SelectQueryBuilder";
+import logSql from "../../utils/logSql";
+import {getLogContext} from "../../utils/logLevel";
 
 export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
     protected createSelectBuilder(request: any) {
@@ -54,6 +56,8 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             sql += this.buildPaginationClause(args.PAGINATION, params);
         }
 
+        logSql("UPDATE", sql, getLogContext(this.config, this.request));
+
         return { sql, params };
     }
 }

package/src/types/ormInterfaces.ts

@@ -204,6 +204,7 @@ export interface iRest<
     clearCache?: () => void;
     skipPrimaryCheck?: boolean;
     websocketBroadcast?: tWebsocketBroadcast;
+    logLevel?: number;
     verbose?: boolean;
     sqlAllowListPath?: string;
 }

package/src/utils/apiHelpers.ts

@@ -4,6 +4,7 @@ import type {AxiosResponse} from "axios";
 import {toastOptions} from "../variables/toastOptions";
 import type {C6RestfulModel} from "../types/ormInterfaces";
 import {notifyToast} from "./toastRuntime";
+import {LogLevel, logWithLevel} from "./logLevel";
 
 
 
@@ -79,7 +80,9 @@ export function removeInvalidKeys<iRestObject>(request: any, c6Tables: {
 
     });
 
-    isTest() || console.log('intersection', intersection)
+    if (!isTest()) {
+        logWithLevel(LogLevel.DEBUG, undefined, console.log, 'intersection', intersection);
+    }
 
     return intersection
 

package/src/utils/cacheManager.ts

@@ -1,5 +1,6 @@
 import type {AxiosPromise} from "axios";
 import type {iCacheAPI} from "../types/ormInterfaces";
+import {LogLevel, logWithLevel, shouldLog} from "./logLevel";
 
 // -----------------------------------------------------------------------------
 // Cache Storage
@@ -36,7 +37,10 @@ function makeCacheKey(
 // -----------------------------------------------------------------------------
 export function clearCache(props?: { ignoreWarning?: boolean }): void {
     if (!props?.ignoreWarning) {
-        console.warn(
+        logWithLevel(
+            LogLevel.WARN,
+            undefined,
+            console.warn,
             "The REST API clearCache should only be used with extreme care!",
         );
     }
@@ -63,12 +67,14 @@ export function checkCache<ResponseDataType = any>(
 
     if (!cached) return false;
 
-    console.groupCollapsed(
-        `%c API cache hit for ${method} ${tableName}`,
-        "color:#0c0",
-    );
-    console.log("Request Data:", requestData);
-    console.groupEnd();
+    if (shouldLog(LogLevel.DEBUG, undefined)) {
+        console.groupCollapsed(
+            `%c API cache hit for ${method} ${tableName}`,
+            "color:#0c0",
+        );
+        console.log("Request Data:", requestData);
+        console.groupEnd();
+    }
 
     return cached.request;
 }

package/src/utils/colorSql.ts

@@ -98,7 +98,7 @@ export default function colorSql(sql: string): string {
 
     /* 4️⃣ SQL keywords */
     s = s.replace(
-        /\b(SELECT|WHERE|AND|OR|ON|IN|BETWEEN|EXISTS|ORDER BY)\b/gi,
+        /\b(SELECT|WHERE|AND|OR|ON|IN|BETWEEN|EXISTS|ORDER BY|GROUP BY|HAVING|SET|VALUES|INSERT|REPLACE|DELETE|UPDATE|DUPLICATE|KEY)\b/gi,
         `${C.KEYWORD}$1${RESET}`,
     );
 
@@ -109,4 +109,4 @@ export default function colorSql(sql: string): string {
     );
 
     return s;
-}
+}