@carbonorm/carbonnode 6.0.3 → 6.0.5

package/src/__tests__/sakila-db/sqlResponses/C6.language.put.json

@@ -1,10 +1,11 @@
 {
   "affected": 1,
+  "insertId": 0,
   "rest": [],
   "sql": {
     "sql": "UPDATE `language` SET `name` = ? WHERE (language.language_id) = ?",
     "values": [
-      "name_updated_1769751",
+      "name_updated_1769973",
       7
     ]
   }

package/src/__tests__/sakila-db/sqlResponses/C6.language.put.lookup.json

@@ -2,8 +2,8 @@
   "rest": [
     {
       "language_id": 7,
-      "name": "name_updated_1769751",
-      "last_update": "2026-01-30T05:41:08.000Z"
+      "name": "name_updated_1769973",
+      "last_update": "2026-02-01T19:13:51.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila-db/sqlResponses/C6.payment.delete.json

@@ -1,5 +1,6 @@
 {
   "affected": 1,
+  "insertId": 0,
   "rest": [],
   "sql": {
     "sql": "DELETE `payment` FROM `payment` WHERE (payment.payment_id) = ?",

package/src/__tests__/sakila-db/sqlResponses/C6.payment.post.json

@@ -1,5 +1,6 @@
 {
   "affected": 1,
+  "insertId": 16050,
   "rest": [],
   "sql": {
     "sql": "INSERT INTO `payment` (\n            `customer_id`, `staff_id`, `rental_id`, `amount`, `payment_date`, `last_update`\n         ) VALUES (\n            ?, ?, ?, ?, ?, ?\n        )",
@@ -8,8 +9,8 @@
       1,
       1,
       1,
-      "2026-01-30 05:41:08",
-      "2026-01-30 05:41:08"
+      "2026-02-01 19:13:51",
+      "2026-02-01 19:13:51"
     ]
   }
 }

package/src/__tests__/sakila-db/sqlResponses/C6.payment.post.latest.json

@@ -6,8 +6,8 @@
       "staff_id": 1,
       "rental_id": 1,
       "amount": "1.00",
-      "payment_date": "2026-01-30T05:41:08.000Z",
-      "last_update": "2026-01-30T05:41:08.000Z"
+      "payment_date": "2026-02-01T19:13:51.000Z",
+      "last_update": "2026-02-01T19:13:51.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila-db/sqlResponses/C6.payment.put.json

@@ -1,5 +1,6 @@
 {
   "affected": 1,
+  "insertId": 0,
   "rest": [],
   "sql": {
     "sql": "UPDATE `payment` SET `amount` = ? WHERE (payment.payment_id) = ?",

package/src/__tests__/sakila-db/sqlResponses/C6.payment.put.lookup.json

@@ -6,8 +6,8 @@
       "staff_id": 1,
       "rental_id": 1,
       "amount": "1.00",
-      "payment_date": "2026-01-30T05:41:08.000Z",
-      "last_update": "2026-01-30T05:41:08.000Z"
+      "payment_date": "2026-02-01T19:13:51.000Z",
+      "last_update": "2026-02-01T19:13:51.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila-db/sqlResponses/C6.rental.delete.json

@@ -1,5 +1,6 @@
 {
   "affected": 1,
+  "insertId": 0,
   "rest": [],
   "sql": {
     "sql": "DELETE `rental` FROM `rental` WHERE (rental.rental_id) = ?",

package/src/__tests__/sakila-db/sqlResponses/C6.rental.post.json

@@ -1,15 +1,16 @@
 {
   "affected": 1,
+  "insertId": 16050,
   "rest": [],
   "sql": {
     "sql": "INSERT INTO `rental` (\n            `rental_date`, `inventory_id`, `customer_id`, `return_date`, `staff_id`, `last_update`\n         ) VALUES (\n            ?, ?, ?, ?, ?, ?\n        )",
     "values": [
-      "2026-01-30 05:41:08",
+      "2026-02-01 19:13:51",
       1,
       1,
-      "2026-01-30 05:41:08",
+      "2026-02-01 19:13:51",
       1,
-      "2026-01-30 05:41:08"
+      "2026-02-01 19:13:51"
     ]
   }
 }

package/src/__tests__/sakila-db/sqlResponses/C6.rental.post.latest.json

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-01-30T05:41:08.000Z",
+      "rental_date": "2026-02-01T19:13:51.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-01-30T05:41:08.000Z",
+      "return_date": "2026-02-01T19:13:51.000Z",
       "staff_id": 1,
-      "last_update": "2026-01-30T05:41:08.000Z"
+      "last_update": "2026-02-01T19:13:51.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila-db/sqlResponses/C6.rental.put.json

@@ -1,10 +1,11 @@
 {
   "affected": 1,
+  "insertId": 0,
   "rest": [],
   "sql": {
     "sql": "UPDATE `rental` SET `rental_date` = ? WHERE (rental.rental_id) = ?",
     "values": [
-      "2026-01-30 05:41:08",
+      "2026-02-01 19:13:51",
       16050
     ]
   }

package/src/__tests__/sakila-db/sqlResponses/C6.rental.put.lookup.json

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-01-30T05:41:08.000Z",
+      "rental_date": "2026-02-01T19:13:51.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-01-30T05:41:08.000Z",
+      "return_date": "2026-02-01T19:13:51.000Z",
       "staff_id": 1,
-      "last_update": "2026-01-30T05:41:08.000Z"
+      "last_update": "2026-02-01T19:13:51.000Z"
     }
   ],
   "sql": {

package/src/executors/HttpExecutor.ts

@@ -529,7 +529,8 @@ export class HttpExecutor<
 
                         if (C6.GET === requestMethod && this.isRestResponse(response)) {
 
-                            const responseData = response.data;
+                            const responseData =
+                                response.data as DetermineResponseDataType<'GET', G['RestTableInterface']>;
 
                             const pageLimit = query?.[C6.PAGINATION]?.[C6.LIMIT];
 

package/src/executors/SqlExecutor.ts

@@ -47,19 +47,19 @@ export class SqlExecutor<
 
             case 'POST': {
                 const result = await this.runQuery();
-                await this.broadcastWebsocketIfConfigured();
+                await this.broadcastWebsocketIfConfigured(result);
                 return result as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             }
 
             case 'PUT': {
                 const result = await this.runQuery();
-                await this.broadcastWebsocketIfConfigured();
+                await this.broadcastWebsocketIfConfigured(result);
                 return result as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             }
 
             case 'DELETE': {
                 const result = await this.runQuery();
-                await this.broadcastWebsocketIfConfigured();
+                await this.broadcastWebsocketIfConfigured(result);
                 return result as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             }
 
@@ -110,7 +110,7 @@ export class SqlExecutor<
         return `'${JSON.stringify(val)}'`;
     }
 
-    private stripRequestMetadata(source: Record<string, any>): Record<string, any> {
+    private stripRequestMetadata(source: Record<string, unknown>): Record<string, unknown> {
         const ignoredKeys = new Set<string>([
             C6C.SELECT,
             C6C.UPDATE,
@@ -128,7 +128,7 @@ export class SqlExecutor<
             "error",
         ]);
 
-        const filtered: Record<string, any> = {};
+        const filtered: Record<string, unknown> = {};
         for (const [key, value] of Object.entries(source)) {
             if (!ignoredKeys.has(key)) {
                 filtered[key] = value;
@@ -137,10 +137,10 @@ export class SqlExecutor<
         return filtered;
     }
 
-    private normalizeRequestPayload(source: Record<string, any>): Record<string, any> {
+    private normalizeRequestPayload(source: Record<string, unknown>): Record<string, unknown> {
         const columns = this.config.restModel.COLUMNS as Record<string, string>;
         const validColumns = new Set(Object.values(columns));
-        const normalized: Record<string, any> = {};
+        const normalized: Record<string, unknown> = {};
 
         for (const [key, value] of Object.entries(source)) {
             const shortKey = columns[key] ?? (key.includes(".") ? key.split(".").pop()! : key);
@@ -152,25 +152,27 @@ export class SqlExecutor<
         return normalized;
     }
 
-    private extractRequestBody(): Record<string, any> {
-        const request = this.request as Record<string, any>;
+
+    private extractRequestBody() {
+        const request = this.request;
 
         if (this.config.requestMethod === C6C.POST) {
-            if (Array.isArray(request.dataInsertMultipleRows) && request.dataInsertMultipleRows.length > 0) {
-                return request.dataInsertMultipleRows[0] as Record<string, any>;
+            const insertRows = request.dataInsertMultipleRows;
+            if (Array.isArray(insertRows) && insertRows.length > 0) {
+                return insertRows[0] as Record<string, unknown>;
             }
             if (C6C.INSERT in request) {
-                return (request as any)[C6C.INSERT] ?? {};
+                return request[C6C.INSERT] ?? {};
             }
             if (C6C.REPLACE in request) {
-                return (request as any)[C6C.REPLACE] ?? {};
+                return request[C6C.REPLACE] ?? {};
             }
             return this.stripRequestMetadata(request);
         }
 
         if (this.config.requestMethod === C6C.PUT) {
             if (request[C6C.UPDATE] && typeof request[C6C.UPDATE] === "object") {
-                return request[C6C.UPDATE] as Record<string, any>;
+                return request[C6C.UPDATE] as Record<string, unknown>;
             }
             return this.stripRequestMetadata(request);
         }
@@ -223,29 +225,136 @@ export class SqlExecutor<
         return Object.keys(pkValues).length > 0 ? pkValues : null;
     }
 
-    private async broadcastWebsocketIfConfigured(): Promise<void> {
+    private extractPrimaryKeyValuesFromData(data: any): Record<string, any> | null {
+        if (!data) return null;
+        const row = Array.isArray(data) ? data[0] : data;
+        if (!row || typeof row !== "object") return null;
+
+        const pkShorts = this.config.restModel.PRIMARY_SHORT;
+        const columns = this.config.restModel.COLUMNS as Record<string, string>;
+        const pkValues: Record<string, any> = {};
+
+        for (const pk of pkShorts) {
+            if (pk in row) {
+                pkValues[pk] = (row as any)[pk];
+                continue;
+            }
+
+            const fullKey = Object.keys(columns).find(
+                (key) => columns[key] === pk,
+            );
+
+            if (fullKey && fullKey in row) {
+                pkValues[pk] = (row as any)[fullKey];
+            }
+        }
+
+        if (pkShorts.length > 0 && Object.keys(pkValues).length < pkShorts.length) {
+            return null;
+        }
+
+        return Object.keys(pkValues).length > 0 ? pkValues : null;
+    }
+
+    private async broadcastWebsocketIfConfigured(
+        response?: DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>
+    ): Promise<void> {
         const broadcast = this.config.websocketBroadcast;
-        if (!broadcast || this.config.requestMethod === C6C.GET) return;
+        this.config.verbose && 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",
+            });
+            return;
+        }
+
+        const normalizedRequest = this.normalizeRequestPayload(this.extractRequestBody());
+        const pkShorts = this.config.restModel.PRIMARY_SHORT ?? [];
+        const columns = this.config.restModel.COLUMNS as Record<string, string>;
+        const validColumns = new Set(Object.values(columns));
+        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,
+        });
+
+        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,
+            });
+            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,
+            });
+            if (insertId !== undefined && pkShorts.length === 1) {
+                const synthesizedRequest = {
+                    ...normalizedRequest,
+                };
+                const now = new Date().toISOString();
+                if (validColumns.has("changed_at") && (synthesizedRequest as Record<string, unknown>).changed_at === undefined) {
+                    synthesizedRequest.changed_at = now;
+                }
+                if (validColumns.has("created_at") && (synthesizedRequest as Record<string, unknown>).created_at === undefined) {
+                    synthesizedRequest.created_at = now;
+                }
+                if (validColumns.has("updated_at") && (synthesizedRequest as Record<string, unknown>).updated_at === undefined) {
+                    synthesizedRequest.updated_at = now;
+                }
+
+                const synthesized = {
+                    ...synthesizedRequest,
+                    [pkShorts[0]]: insertId,
+                };
+                // @ts-ignore - todo
+                responseRest = [synthesized];
+                responsePrimaryKey = {
+                    [pkShorts[0]]: insertId,
+                };
+                this.config.verbose && console.log("[SQL EXECUTOR] 📣 synthesized response payload", {
+                    synthesized,
+                    responsePrimaryKey,
+                });
+            }
+        }
 
         const payload: iRestWebsocketPayload = {
             REST: {
                 TABLE_NAME: this.config.restModel.TABLE_NAME as string,
                 TABLE_PREFIX: this.config.C6?.PREFIX ?? "",
                 METHOD: this.config.requestMethod,
-                REQUEST: this.normalizeRequestPayload(this.extractRequestBody()),
+                REQUEST: normalizedRequest,
                 REQUEST_PRIMARY_KEY: this.extractPrimaryKeyValues(),
+                RESPONSE: responseRest,
+                RESPONSE_PRIMARY_KEY: responsePrimaryKey,
             },
         };
 
+        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket payload ready", payload);
+
         try {
+            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch start");
             await broadcast(payload);
+            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch complete");
         } catch (error) {
             if (this.config.verbose) {
                 console.error("[SQL EXECUTOR] websocketBroadcast failed", error);
             }
         }
     }
-    async runQuery() {
+    async runQuery(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>> {
         const {TABLE_NAME} = this.config.restModel;
         const method = this.config.requestMethod;
         let builder: SelectQueryBuilder<G> | UpdateQueryBuilder<G> | DeleteQueryBuilder<G> | PostQueryBuilder<G>;
@@ -286,14 +395,15 @@ export class SqlExecutor<
                 return {
                     rest: result.map(this.serialize),
                     sql: {sql, values}
-                };
+                } as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             } else {
                 this.config.verbose &&  console.log(`[SQL EXECUTOR] ✏️ Rows affected:`, result.affectedRows);
                 return {
-                    affected: result.affectedRows,
-                    rest: [],
+                    affected: result.affectedRows as number,
+                    insertId: result.insertId as number,
+                    rest: [], // TODO - remove rest empty array from non-GET responses?
                     sql: {sql, values}
-                };
+                } as DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
             }
         });
     }

package/src/handlers/ExpressHandler.ts

@@ -2,7 +2,7 @@ import type {Request, Response, NextFunction} from "express";
 import type {Pool} from "mysql2/promise";
 import {C6C} from "../constants/C6Constants";
 import restRequest from "../api/restRequest";
-import type {iC6Object, iRestMethods} from "../types/ormInterfaces";
+import type {iC6Object, iRestMethods, tWebsocketBroadcast} from "../types/ormInterfaces";
 
 
 // TODO - WE MUST make this a generic - optional, but helpful
@@ -11,10 +11,12 @@ export function ExpressHandler({
     C6,
     mysqlPool,
     sqlAllowListPath,
+    websocketBroadcast,
 }: {
     C6: iC6Object;
     mysqlPool: Pool;
     sqlAllowListPath?: string;
+    websocketBroadcast?: tWebsocketBroadcast;
 }) {
 
     return async (req: Request, res: Response, next: NextFunction) => {
@@ -101,6 +103,7 @@ export function ExpressHandler({
                 C6,
                 mysqlPool,
                 sqlAllowListPath,
+                websocketBroadcast,
                 requestMethod: method,
                 restModel: C6.TABLES[table]
             })(payload);

package/src/types/ormInterfaces.ts

@@ -77,6 +77,11 @@ export type RequestGetPutDeleteBody<T extends { [key: string]: any } = any> = T
     PAGINATION?: Pagination<T>;
 };
 
+export type RequestPostBody<T extends { [key: string]: any } = any> = T | {
+    INSERT?: Partial<T>;
+    REPLACE?: Partial<T>;
+};
+
 export type iAPI<T extends { [key: string]: any }> = T & {
     dataInsertMultipleRows?: T[];
     cacheResults?: boolean;
@@ -94,7 +99,7 @@ export type RequestQueryBody<
     Overrides extends { [key: string]: any } = {}
 > = Method extends 'GET' | 'PUT' | 'DELETE'
     ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>>
-    : iAPI<Modify<T, Overrides> & Custom>;
+    : iAPI<RequestPostBody<Modify<T, Overrides> & Custom>>;
 
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;
@@ -119,12 +124,15 @@ export type C6RestResponse<
     RestData extends { [key: string]: any },
     Overrides = {}
 > = {
-    rest: Method extends 'GET' ? Modify<RestData, Overrides>[] : Modify<RestData, Overrides>;
+    rest: Method extends 'GET' ? Modify<RestData, Overrides>[] : never;
     session?: any;
     sql?: any;
 } & (Method extends 'GET'
     ? { next?: () => Promise<DetermineResponseDataType<'GET', RestData, Overrides>> }
-    : {});
+    : {
+        affected: number,
+        insertId?: number | string,
+    });
 
 export interface iC6RestResponse<RestData> {
     // Backwards compatibility: base interface for rest/sql/session (singular)
@@ -172,6 +180,8 @@ export type iRestWebsocketPayload = {
         METHOD: iRestMethods;
         REQUEST: Record<string, any>;
         REQUEST_PRIMARY_KEY: Record<string, any> | null;
+        RESPONSE?: Record<string, any> | Record<string, any>[];
+        RESPONSE_PRIMARY_KEY?: Record<string, any> | null;
     };
 };