@carbonorm/carbonnode 6.0.10 → 6.0.12

package/dist/executors/SqlExecutor.d.ts

@@ -18,5 +18,10 @@ export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
     private extractPrimaryKeyValuesFromData;
     private broadcastWebsocketIfConfigured;
     runQuery(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
+    private getQueryBuilder;
+    private buildSqlExecutionContext;
+    private createResponseFromQueryResult;
+    private createLifecycleHookResponse;
+    private executeQueryWithLifecycle;
     private validateSqlAllowList;
 }

package/dist/handlers/ExpressHandler.d.ts

@@ -1,9 +1,16 @@
-import type { Request, Response, NextFunction } from "express";
+import type { Request, Response, NextFunction, Router } from "express";
 import type { Pool } from "mysql2/promise";
 import type { iC6Object, tWebsocketBroadcast } from "../types/ormInterfaces";
-export declare function ExpressHandler({ C6, mysqlPool, sqlAllowListPath, websocketBroadcast, }: {
+type iExpressHandlerConfig = {
     C6: iC6Object;
     mysqlPool: Pool;
     sqlAllowListPath?: string;
     websocketBroadcast?: tWebsocketBroadcast;
-}): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+type iRestExpressRequestConfig = iExpressHandlerConfig & {
+    router: Pick<Router, "all">;
+    routePath?: string;
+};
+export declare function restExpressRequest({ router, routePath, ...handlerConfig }: iRestExpressRequestConfig): void;
+export declare function ExpressHandler({ C6, mysqlPool, sqlAllowListPath, websocketBroadcast, }: iExpressHandlerConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export {};

package/dist/index.cjs.js

@@ -2973,7 +2973,7 @@ function colorSql(sql) {
     return s;
 }
 
-var version = "6.0.10";
+var version = "6.0.12";
 
 var DEFAULT_STEP = 8;
 function parseSemver(version) {
@@ -3494,12 +3494,18 @@ var SqlExecutor = /** @class */ (function (_super) {
     }
     SqlExecutor.prototype.execute = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, logContext, _a, rest, result, result, result;
+            var TABLE_NAME, method, logContext, response, _a, rest, getResponse, restRows, result, result, result;
             return tslib.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         TABLE_NAME = this.config.restModel.TABLE_NAME;
                         method = this.config.requestMethod;
+                        return [4 /*yield*/, this.runLifecycleHooks("beforeProcessing", {
+                                config: this.config,
+                                request: this.request,
+                            })];
+                    case 1:
+                        _b.sent();
                         // Normalize singular T-shaped requests into complex ORM shape (GET/PUT/DELETE)
                         try {
                             this.request = normalizeSingularRequest(method, this.request, this.config.restModel, undefined);
@@ -3513,45 +3519,54 @@ var SqlExecutor = /** @class */ (function (_super) {
                         logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE9 Request:", this.request);
                         _a = method;
                         switch (_a) {
-                            case 'GET': return [3 /*break*/, 1];
-                            case 'POST': return [3 /*break*/, 3];
-                            case 'PUT': return [3 /*break*/, 6];
-                            case 'DELETE': return [3 /*break*/, 9];
+                            case 'GET': return [3 /*break*/, 2];
+                            case 'POST': return [3 /*break*/, 4];
+                            case 'PUT': return [3 /*break*/, 7];
+                            case 'DELETE': return [3 /*break*/, 10];
                         }
-                        return [3 /*break*/, 12];
-                    case 1: return [4 /*yield*/, this.runQuery()];
-                    case 2:
+                        return [3 /*break*/, 13];
+                    case 2: return [4 /*yield*/, this.runQuery()];
+                    case 3:
                         rest = _b.sent();
                         if (this.config.reactBootstrap) {
+                            getResponse = rest;
+                            restRows = Array.isArray(getResponse.rest)
+                                ? getResponse.rest
+                                : [getResponse.rest];
                             this.config.reactBootstrap.updateRestfulObjectArrays({
-                                dataOrCallback: rest.rest,
+                                dataOrCallback: restRows,
                                 stateKey: this.config.restModel.TABLE_NAME,
                                 uniqueObjectId: this.config.restModel.PRIMARY_SHORT,
                             });
                         }
-                        return [2 /*return*/, rest];
-                    case 3: return [4 /*yield*/, this.runQuery()];
-                    case 4:
+                        response = rest;
+                        return [3 /*break*/, 14];
+                    case 4: return [4 /*yield*/, this.runQuery()];
+                    case 5:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 5:
+                    case 6:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 6: return [4 /*yield*/, this.runQuery()];
-                    case 7:
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 7: return [4 /*yield*/, this.runQuery()];
+                    case 8:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 8:
+                    case 9:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 9: return [4 /*yield*/, this.runQuery()];
-                    case 10:
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 10: return [4 /*yield*/, this.runQuery()];
+                    case 11:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 11:
+                    case 12:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 12: throw new Error("Unsupported request method: ".concat(method));
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 13: throw new Error("Unsupported request method: ".concat(method));
+                    case 14: return [2 /*return*/, response];
                 }
             });
         });
@@ -3848,65 +3863,137 @@ var SqlExecutor = /** @class */ (function (_super) {
     };
     SqlExecutor.prototype.runQuery = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, builder, QueryResult, logContext, formatted, toUnnamed, _a, sql, values;
+            var method, tableName, logContext, sqlExecution;
             var _this = this;
-            return tslib.__generator(this, function (_b) {
-                switch (_b.label) {
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        TABLE_NAME = this.config.restModel.TABLE_NAME;
                         method = this.config.requestMethod;
-                        switch (method) {
-                            case 'GET':
-                                builder = new SelectQueryBuilder(this.config, this.request);
-                                break;
-                            case 'PUT':
-                                builder = new UpdateQueryBuilder(this.config, this.request);
-                                break;
-                            case 'DELETE':
-                                builder = new DeleteQueryBuilder(this.config, this.request);
-                                break;
-                            case 'POST':
-                                builder = new PostQueryBuilder(this.config, this.request);
-                                break;
-                            default:
-                                throw new Error("Unsupported query method: ".concat(method));
-                        }
-                        QueryResult = builder.build(TABLE_NAME);
+                        tableName = this.config.restModel.TABLE_NAME;
                         logContext = getLogContext(this.config, this.request);
-                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), QueryResult);
-                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
-                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(method.toUpperCase(), " SQL:"), formatted);
-                        toUnnamed = namedPlaceholders();
-                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
-                        return [4 /*yield*/, this.validateSqlAllowList(sql)];
+                        sqlExecution = this.buildSqlExecutionContext(method, tableName, logContext);
+                        return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () { return tslib.__generator(this, function (_a) {
+                                return [2 /*return*/, this.executeQueryWithLifecycle(conn, method, sqlExecution, logContext)];
+                            }); }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    SqlExecutor.prototype.getQueryBuilder = function (method) {
+        switch (method) {
+            case C6Constants.GET:
+                return new SelectQueryBuilder(this.config, this.request);
+            case C6Constants.PUT:
+                return new UpdateQueryBuilder(this.config, this.request);
+            case C6Constants.DELETE:
+                return new DeleteQueryBuilder(this.config, this.request);
+            case C6Constants.POST:
+                return new PostQueryBuilder(this.config, this.request);
+            default:
+                throw new Error("Unsupported query method: ".concat(method));
+        }
+    };
+    SqlExecutor.prototype.buildSqlExecutionContext = function (method, tableName, logContext) {
+        var builder = this.getQueryBuilder(method);
+        var queryResult = builder.build(tableName);
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), queryResult);
+        var formatted = this.formatSQLWithParams(queryResult.sql, queryResult.params);
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(method.toUpperCase(), " SQL:"), formatted);
+        var toUnnamed = namedPlaceholders();
+        var _a = toUnnamed(queryResult.sql, queryResult.params), sql = _a[0], values = _a[1];
+        return { sql: sql, values: values };
+    };
+    SqlExecutor.prototype.createResponseFromQueryResult = function (method, result, sqlExecution, logContext) {
+        if (method === C6Constants.GET) {
+            return {
+                rest: result.map(this.serialize),
+                sql: { sql: sqlExecution.sql, values: sqlExecution.values },
+            };
+        }
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
+        return {
+            affected: result.affectedRows,
+            insertId: result.insertId,
+            rest: [],
+            sql: { sql: sqlExecution.sql, values: sqlExecution.values },
+        };
+    };
+    SqlExecutor.prototype.createLifecycleHookResponse = function (response) {
+        var data = Object.assign({ success: true }, response);
+        return { data: data };
+    };
+    SqlExecutor.prototype.executeQueryWithLifecycle = function (conn, method, sqlExecution, logContext) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var useTransaction, committed, result, response, hookResponse, err_1, rollbackErr_1;
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        useTransaction = method !== C6Constants.GET;
+                        committed = false;
+                        _a.label = 1;
                     case 1:
-                        _b.sent();
-                        return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                var result;
-                                return tslib.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, conn.query(sql, values)];
-                                        case 1:
-                                            result = (_a.sent())[0];
-                                            if (method === 'GET') {
-                                                return [2 /*return*/, {
-                                                        rest: result.map(this.serialize),
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                            else {
-                                                logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
-                                                return [2 /*return*/, {
-                                                        affected: result.affectedRows,
-                                                        insertId: result.insertId,
-                                                        rest: [], // TODO - remove rest empty array from non-GET responses?
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                    }
-                                });
-                            }); })];
-                    case 2: return [2 /*return*/, _b.sent()];
+                        _a.trys.push([1, 11, , 16]);
+                        if (!useTransaction) return [3 /*break*/, 3];
+                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDFE Beginning transaction");
+                        return [4 /*yield*/, conn.beginTransaction()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, this.validateSqlAllowList(sqlExecution.sql)];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this.runLifecycleHooks("beforeExecution", {
+                                config: this.config,
+                                request: this.request,
+                                sqlExecution: sqlExecution,
+                            })];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, conn.query(sqlExecution.sql, sqlExecution.values)];
+                    case 6:
+                        result = (_a.sent())[0];
+                        response = this.createResponseFromQueryResult(method, result, sqlExecution, logContext);
+                        hookResponse = this.createLifecycleHookResponse(response);
+                        return [4 /*yield*/, this.runLifecycleHooks("afterExecution", {
+                                config: this.config,
+                                request: this.request,
+                                response: hookResponse,
+                            })];
+                    case 7:
+                        _a.sent();
+                        if (!useTransaction) return [3 /*break*/, 9];
+                        return [4 /*yield*/, conn.commit()];
+                    case 8:
+                        _a.sent();
+                        committed = true;
+                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDFE Transaction committed");
+                        _a.label = 9;
+                    case 9: return [4 /*yield*/, this.runLifecycleHooks("afterCommit", {
+                            config: this.config,
+                            request: this.request,
+                            response: hookResponse,
+                        })];
+                    case 10:
+                        _a.sent();
+                        return [2 /*return*/, response];
+                    case 11:
+                        err_1 = _a.sent();
+                        if (!(useTransaction && !committed)) return [3 /*break*/, 15];
+                        _a.label = 12;
+                    case 12:
+                        _a.trys.push([12, 14, , 15]);
+                        return [4 /*yield*/, conn.rollback()];
+                    case 13:
+                        _a.sent();
+                        logWithLevel(exports.LogLevel.WARN, logContext, console.warn, "[SQL EXECUTOR] \uD83E\uDDFE Transaction rolled back");
+                        return [3 /*break*/, 15];
+                    case 14:
+                        rollbackErr_1 = _a.sent();
+                        logWithLevel(exports.LogLevel.ERROR, logContext, console.error, "[SQL EXECUTOR] Rollback failed", rollbackErr_1);
+                        return [3 /*break*/, 15];
+                    case 15: throw err_1;
+                    case 16: return [2 /*return*/];
                 }
             });
         });
@@ -3941,6 +4028,10 @@ var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
     SqlExecutor: SqlExecutor
 });
 
+function restExpressRequest(_a) {
+    var router = _a.router, _b = _a.routePath, routePath = _b === void 0 ? "/rest/:table{/:primary}" : _b, handlerConfig = tslib.__rest(_a, ["router", "routePath"]);
+    router.all(routePath, ExpressHandler(handlerConfig));
+}
 // TODO - WE MUST make this a generic - optional, but helpful
 // note sure how it would help anyone actually...
 function ExpressHandler(_a) {
@@ -4221,6 +4312,7 @@ exports.removeInvalidKeys = removeInvalidKeys;
 exports.removePrefixIfExists = removePrefixIfExists;
 exports.resolveDerivedTable = resolveDerivedTable;
 exports.resolveLogLevel = resolveLogLevel;
+exports.restExpressRequest = restExpressRequest;
 exports.restOrm = restOrm;
 exports.restRequest = restRequest;
 exports.setCache = setCache;