@carbonorm/carbonnode 6.0.3 → 6.0.5

package/dist/executors/SqlExecutor.d.ts

@@ -15,21 +15,8 @@ export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
     private normalizeRequestPayload;
     private extractRequestBody;
     private extractPrimaryKeyValues;
+    private extractPrimaryKeyValuesFromData;
     private broadcastWebsocketIfConfigured;
-    runQuery(): Promise<{
-        rest: any;
-        sql: {
-            sql: any;
-            values: any;
-        };
-        affected?: undefined;
-    } | {
-        affected: any;
-        rest: never[];
-        sql: {
-            sql: any;
-            values: any;
-        };
-    }>;
+    runQuery(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
     private validateSqlAllowList;
 }

package/dist/handlers/ExpressHandler.d.ts

@@ -1,8 +1,9 @@
 import type { Request, Response, NextFunction } from "express";
 import type { Pool } from "mysql2/promise";
-import type { iC6Object } from "../types/ormInterfaces";
-export declare function ExpressHandler({ C6, mysqlPool, sqlAllowListPath, }: {
+import type { iC6Object, tWebsocketBroadcast } from "../types/ormInterfaces";
+export declare function ExpressHandler({ C6, mysqlPool, sqlAllowListPath, websocketBroadcast, }: {
     C6: iC6Object;
     mysqlPool: Pool;
     sqlAllowListPath?: string;
+    websocketBroadcast?: tWebsocketBroadcast;
 }): (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/index.cjs.js

@@ -3131,21 +3131,21 @@ var SqlExecutor = /** @class */ (function (_super) {
                     case 3: return [4 /*yield*/, this.runQuery()];
                     case 4:
                         result = _b.sent();
-                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured()];
+                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
                     case 5:
                         _b.sent();
                         return [2 /*return*/, result];
                     case 6: return [4 /*yield*/, this.runQuery()];
                     case 7:
                         result = _b.sent();
-                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured()];
+                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
                     case 8:
                         _b.sent();
                         return [2 /*return*/, result];
                     case 9: return [4 /*yield*/, this.runQuery()];
                     case 10:
                         result = _b.sent();
-                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured()];
+                        return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
                     case 11:
                         _b.sent();
                         return [2 /*return*/, result];
@@ -3254,8 +3254,9 @@ var SqlExecutor = /** @class */ (function (_super) {
         var _a, _b;
         var request = this.request;
         if (this.config.requestMethod === C6Constants.POST) {
-            if (Array.isArray(request.dataInsertMultipleRows) && request.dataInsertMultipleRows.length > 0) {
-                return request.dataInsertMultipleRows[0];
+            var insertRows = request.dataInsertMultipleRows;
+            if (Array.isArray(insertRows) && insertRows.length > 0) {
+                return insertRows[0];
             }
             if (C6Constants.INSERT in request) {
                 return (_a = request[C6Constants.INSERT]) !== null && _a !== void 0 ? _a : {};
@@ -3316,34 +3317,124 @@ var SqlExecutor = /** @class */ (function (_super) {
         }
         return Object.keys(pkValues).length > 0 ? pkValues : null;
     };
-    SqlExecutor.prototype.broadcastWebsocketIfConfigured = function () {
+    SqlExecutor.prototype.extractPrimaryKeyValuesFromData = function (data) {
+        if (!data)
+            return null;
+        var row = Array.isArray(data) ? data[0] : data;
+        if (!row || typeof row !== "object")
+            return null;
+        var pkShorts = this.config.restModel.PRIMARY_SHORT;
+        var columns = this.config.restModel.COLUMNS;
+        var pkValues = {};
+        var _loop_2 = function (pk) {
+            if (pk in row) {
+                pkValues[pk] = row[pk];
+                return "continue";
+            }
+            var fullKey = Object.keys(columns).find(function (key) { return columns[key] === pk; });
+            if (fullKey && fullKey in row) {
+                pkValues[pk] = row[fullKey];
+            }
+        };
+        for (var _i = 0, pkShorts_1 = pkShorts; _i < pkShorts_1.length; _i++) {
+            var pk = pkShorts_1[_i];
+            _loop_2(pk);
+        }
+        if (pkShorts.length > 0 && Object.keys(pkValues).length < pkShorts.length) {
+            return null;
+        }
+        return Object.keys(pkValues).length > 0 ? pkValues : null;
+    };
+    SqlExecutor.prototype.broadcastWebsocketIfConfigured = function (response) {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var broadcast, payload, error_1;
+            var broadcast, normalizedRequest, pkShorts, columns, validColumns, responseRest, responsePrimaryKey, insertId, synthesizedRequest, now, synthesized, payload, error_1;
             var _a, _b;
-            return tslib.__generator(this, function (_c) {
-                switch (_c.label) {
+            var _c, _d, _e;
+            return tslib.__generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         broadcast = this.config.websocketBroadcast;
-                        if (!broadcast || this.config.requestMethod === C6Constants.GET)
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 broadcastWebsocketIfConfigured start", {
+                            method: this.config.requestMethod,
+                            hasBroadcast: Boolean(broadcast),
+                        });
+                        if (!broadcast || this.config.requestMethod === C6Constants.GET) {
+                            this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast skipped", {
+                                reason: !broadcast ? "no broadcast configured" : "GET request",
+                            });
                             return [2 /*return*/];
+                        }
+                        normalizedRequest = this.normalizeRequestPayload(this.extractRequestBody());
+                        pkShorts = (_c = this.config.restModel.PRIMARY_SHORT) !== null && _c !== void 0 ? _c : [];
+                        columns = this.config.restModel.COLUMNS;
+                        validColumns = new Set(Object.values(columns));
+                        responseRest = response === null || response === void 0 ? void 0 : response.rest;
+                        responsePrimaryKey = this.extractPrimaryKeyValuesFromData(responseRest);
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket request payload", {
+                            normalizedRequest: normalizedRequest,
+                            requestPrimaryKey: this.extractPrimaryKeyValues(),
+                            pkShorts: pkShorts,
+                        });
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket response payload", {
+                            responseRest: responseRest,
+                            responsePrimaryKey: responsePrimaryKey,
+                        });
+                        if ((responseRest === null || (Array.isArray(responseRest) && responseRest.length === 0))
+                            && this.config.requestMethod === C6Constants.POST) {
+                            this.config.verbose && console.log("[SQL EXECUTOR] 📣 response rest empty, attempting synthesize", {
+                                responseRest: responseRest,
+                            });
+                            insertId = response === null || response === void 0 ? void 0 : response.insertId;
+                            this.config.verbose && console.log("[SQL EXECUTOR] 📣 POST insertId lookup", {
+                                insertId: insertId,
+                            });
+                            if (insertId !== undefined && pkShorts.length === 1) {
+                                synthesizedRequest = tslib.__assign({}, normalizedRequest);
+                                now = new Date().toISOString();
+                                if (validColumns.has("changed_at") && synthesizedRequest.changed_at === undefined) {
+                                    synthesizedRequest.changed_at = now;
+                                }
+                                if (validColumns.has("created_at") && synthesizedRequest.created_at === undefined) {
+                                    synthesizedRequest.created_at = now;
+                                }
+                                if (validColumns.has("updated_at") && synthesizedRequest.updated_at === undefined) {
+                                    synthesizedRequest.updated_at = now;
+                                }
+                                synthesized = tslib.__assign(tslib.__assign({}, synthesizedRequest), (_a = {}, _a[pkShorts[0]] = insertId, _a));
+                                // @ts-ignore - todo
+                                responseRest = [synthesized];
+                                responsePrimaryKey = (_b = {},
+                                    _b[pkShorts[0]] = insertId,
+                                    _b);
+                                this.config.verbose && console.log("[SQL EXECUTOR] 📣 synthesized response payload", {
+                                    synthesized: synthesized,
+                                    responsePrimaryKey: responsePrimaryKey,
+                                });
+                            }
+                        }
                         payload = {
                             REST: {
                                 TABLE_NAME: this.config.restModel.TABLE_NAME,
-                                TABLE_PREFIX: (_b = (_a = this.config.C6) === null || _a === void 0 ? void 0 : _a.PREFIX) !== null && _b !== void 0 ? _b : "",
+                                TABLE_PREFIX: (_e = (_d = this.config.C6) === null || _d === void 0 ? void 0 : _d.PREFIX) !== null && _e !== void 0 ? _e : "",
                                 METHOD: this.config.requestMethod,
-                                REQUEST: this.normalizeRequestPayload(this.extractRequestBody()),
+                                REQUEST: normalizedRequest,
                                 REQUEST_PRIMARY_KEY: this.extractPrimaryKeyValues(),
+                                RESPONSE: responseRest,
+                                RESPONSE_PRIMARY_KEY: responsePrimaryKey,
                             },
                         };
-                        _c.label = 1;
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket payload ready", payload);
+                        _f.label = 1;
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _f.trys.push([1, 3, , 4]);
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch start");
                         return [4 /*yield*/, broadcast(payload)];
                     case 2:
-                        _c.sent();
+                        _f.sent();
+                        this.config.verbose && console.log("[SQL EXECUTOR] 📣 websocket broadcast dispatch complete");
                         return [3 /*break*/, 4];
                     case 3:
-                        error_1 = _c.sent();
+                        error_1 = _f.sent();
                         if (this.config.verbose) {
                             console.error("[SQL EXECUTOR] websocketBroadcast failed", error_1);
                         }
@@ -3404,7 +3495,8 @@ var SqlExecutor = /** @class */ (function (_super) {
                                                 this.config.verbose && console.log("[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
                                                 return [2 /*return*/, {
                                                         affected: result.affectedRows,
-                                                        rest: [],
+                                                        insertId: result.insertId,
+                                                        rest: [], // TODO - remove rest empty array from non-GET responses?
                                                         sql: { sql: sql, values: values }
                                                     }];
                                             }
@@ -3450,7 +3542,7 @@ var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
 // note sure how it would help anyone actually...
 function ExpressHandler(_a) {
     var _this = this;
-    var C6 = _a.C6, mysqlPool = _a.mysqlPool, sqlAllowListPath = _a.sqlAllowListPath;
+    var C6 = _a.C6, mysqlPool = _a.mysqlPool, sqlAllowListPath = _a.sqlAllowListPath, websocketBroadcast = _a.websocketBroadcast;
     return function (req, res, next) { return tslib.__awaiter(_this, void 0, void 0, function () {
         var incomingMethod, table, primary, methodOverrideRaw, methodOverride, treatAsGet, method, payload, restModel, primaryKeys_1, primaryShortKeys_1, columnMap_1, resolveShortKey_1, hasPrimaryKeyValues, primaryKeyName, response, err_1;
         var _a, _b, _c, _d, _e, _f, _g;
@@ -3537,6 +3629,7 @@ function ExpressHandler(_a) {
                             C6: C6,
                             mysqlPool: mysqlPool,
                             sqlAllowListPath: sqlAllowListPath,
+                            websocketBroadcast: websocketBroadcast,
                             requestMethod: method,
                             restModel: C6.TABLES[table]
                         })(payload)];