@carbonorm/carbonnode 3.3.9 → 3.4.0

package/dist/api/executors/SqlExecutor.d.ts

@@ -2,21 +2,13 @@ import { OrmGenerics } from "../types/ormGenerics";
 import { DetermineResponseDataType } from "../types/ormInterfaces";
 import { ResultSetHeader } from 'mysql2/promise';
 import { Executor } from "./Executor";
+type QueryType = 'select' | 'update' | 'delete';
 export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
     execute(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
     private withConnection;
     serialize: (row: any) => {
         [k: string]: unknown;
     };
-    select(table: G['RestShortTableName'], primary: string | undefined, args: any): Promise<{
-        rest: {
-            [k: string]: unknown;
-        }[];
-        sql: {
-            sql: any;
-            values: any;
-        };
-    }>;
     insert(table: G['RestShortTableName'], data: Record<string, any>): Promise<{
         rest: ResultSetHeader;
         sql: {
@@ -24,22 +16,24 @@ export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
             placeholders: string;
         };
     }>;
-    update(table: G['RestShortTableName'], primary: string[], data: Record<string, any>): Promise<{
-        rest: ResultSetHeader;
+    formatSQLWithParams(sql: string, params: any[] | {
+        [key: string]: any;
+    }): string;
+    private formatValue;
+    runQuery(type: QueryType, table: G['RestShortTableName'], args: any): Promise<{
+        rest: any;
         sql: {
-            sql: string;
-            values: any[];
+            sql: any;
+            values: any;
         };
-    }>;
-    delete(table: G['RestShortTableName'], primary: string[], args: Record<string, any>): Promise<{
-        rest: ResultSetHeader;
+        affected?: undefined;
+    } | {
+        affected: any;
+        rest: never[];
         sql: {
-            sql: string;
-            args: Record<string, any>;
+            sql: any;
+            values: any;
         };
     }>;
-    formatSQLWithParams(sql: string, params: any[] | {
-        [key: string]: any;
-    }): string;
-    private formatValue;
 }
+export {};

package/dist/api/orm/queries/DeleteQueryBuilder.d.ts

@@ -1,6 +1,9 @@
 import { OrmGenerics } from "../../types/ormGenerics";
-import { PaginationBuilder } from "../builders/PaginationBuilder";
 import { SqlBuilderResult } from "../utils/sqlUtils";
-export declare class DeleteQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G> {
-    build(table: string, args?: any): SqlBuilderResult;
+import { JoinBuilder } from "../builders/JoinBuilder";
+export declare class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
+    build(table: string, args: {
+        JOIN?: any;
+        WHERE?: any;
+    }): SqlBuilderResult;
 }

package/dist/index.cjs.js

@@ -1368,6 +1368,25 @@ var JoinBuilder = /** @class */ (function (_super) {
     return JoinBuilder;
 }(ConditionBuilder));
 
+var DeleteQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(DeleteQueryBuilder, _super);
+    function DeleteQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DeleteQueryBuilder.prototype.build = function (table, args) {
+        var params = this.useNamedParams ? {} : [];
+        var sql = "DELETE `".concat(table, "` FROM `").concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+        return { sql: sql, params: params };
+    };
+    return DeleteQueryBuilder;
+}(JoinBuilder));
+
 var PaginationBuilder = /** @class */ (function (_super) {
     tslib.__extends(PaginationBuilder, _super);
     function PaginationBuilder() {
@@ -1464,6 +1483,42 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
     return SelectQueryBuilder;
 }(PaginationBuilder));
 
+var UpdateQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(UpdateQueryBuilder, _super);
+    function UpdateQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UpdateQueryBuilder.prototype.build = function (table, data, args) {
+        if (args === void 0) { args = {}; }
+        var params = this.useNamedParams ? {} : [];
+        var sql = "UPDATE `".concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        var setClauses = Object.entries(data).map(function (_a) {
+            var col = _a[0], val = _a[1];
+            if (Array.isArray(params)) {
+                params.push(val);
+                return "`".concat(col, "` = ?");
+            }
+            else {
+                var key = "param".concat(Object.keys(params).length);
+                params[key] = val;
+                return "`".concat(col, "` = :").concat(key);
+            }
+        });
+        sql += " SET ".concat(setClauses.join(', '));
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        }
+        return { sql: sql, params: params };
+    };
+    return UpdateQueryBuilder;
+}(PaginationBuilder));
+
 var SqlExecutor = /** @class */ (function (_super) {
     tslib.__extends(SqlExecutor, _super);
     function SqlExecutor() {
@@ -1492,7 +1547,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                             case 'DELETE': return [3 /*break*/, 7];
                         }
                         return [3 /*break*/, 9];
-                    case 1: return [4 /*yield*/, this.select(TABLE_NAME, undefined, this.request)];
+                    case 1: return [4 /*yield*/, this.runQuery('select', TABLE_NAME, this.request)];
                     case 2:
                         rest = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 GET result:", rest);
@@ -1503,13 +1558,12 @@ var SqlExecutor = /** @class */ (function (_super) {
                         console.log("[SQL EXECUTOR] \u2705 POST result:", result);
                         created = { rest: result, created: true };
                         return [2 /*return*/, created];
-                    case 5: return [4 /*yield*/, this.update(TABLE_NAME, [], this.request)];
+                    case 5: return [4 /*yield*/, this.runQuery('update', TABLE_NAME, this.request)];
                     case 6:
                         result = _b.sent();
-                        console.log("[SQL EXECUTOR] \u2705 PUT result:", result);
                         updated = tslib.__assign(tslib.__assign({}, result), { updated: true, rowCount: result.rest.affectedRows });
                         return [2 /*return*/, updated];
-                    case 7: return [4 /*yield*/, this.delete(TABLE_NAME, [], this.request)];
+                    case 7: return [4 /*yield*/, this.runQuery('delete', TABLE_NAME, this.request)];
                     case 8:
                         result = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 DELETE result:", result);
@@ -1549,42 +1603,6 @@ var SqlExecutor = /** @class */ (function (_super) {
             });
         });
     };
-    SqlExecutor.prototype.select = function (table, primary, args) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var QueryResult, formatted, toUnnamed, _a, sql, values;
-            var _this = this;
-            return tslib.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        QueryResult = (new SelectQueryBuilder(this.config, this.request)).build(table, args, primary);
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated SELECT SQL:", QueryResult);
-                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Formatted SELECT SQL:", formatted);
-                        toUnnamed = namedPlaceholders();
-                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
-                        return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                var rows;
-                                return tslib.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, conn.query(sql, values)];
-                                        case 1:
-                                            rows = (_a.sent())[0];
-                                            console.log("[SQL EXECUTOR] \uD83D\uDCE6 Rows fetched:", rows);
-                                            return [2 /*return*/, {
-                                                    rest: rows.map(this.serialize),
-                                                    sql: {
-                                                        sql: sql,
-                                                        values: values
-                                                    }
-                                                }];
-                                    }
-                                });
-                            }); })];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
     SqlExecutor.prototype.insert = function (table, data) {
         return tslib.__awaiter(this, void 0, void 0, function () {
             var keys, values, placeholders, sql;
@@ -1620,79 +1638,6 @@ var SqlExecutor = /** @class */ (function (_super) {
             });
         });
     };
-    SqlExecutor.prototype.update = function (table, primary, data) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var keys, values, updates, sql;
-            var _this = this;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(primary === null || primary === void 0 ? void 0 : primary.length))
-                            throw new Error('Primary key is required for update');
-                        keys = Object.keys(data);
-                        values = keys.map(function (k) { return data[k]; });
-                        updates = keys.map(function (k) { return "`".concat(k, "` = ?"); }).join(', ');
-                        sql = "UPDATE `".concat(table, "`\n                     SET ").concat(updates, "\n                     WHERE `").concat(primary[0], "` = ?");
-                        values.push(data[primary[0]]);
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated UPDATE SQL:", sql);
-                        console.log("[SQL EXECUTOR] \uD83D\uDD22 Values:", values);
-                        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.execute(sql, values)];
-                                        case 1:
-                                            result = (_a.sent())[0];
-                                            return [2 /*return*/, {
-                                                    rest: result,
-                                                    sql: {
-                                                        sql: sql,
-                                                        values: values
-                                                    }
-                                                }];
-                                    }
-                                });
-                            }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    SqlExecutor.prototype.delete = function (table, primary, args) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var key, sql;
-            var _this = this;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        key = primary === null || primary === void 0 ? void 0 : primary[0];
-                        if (!key || !(args === null || args === void 0 ? void 0 : args[key]))
-                            throw new Error('Primary key and value required for delete');
-                        sql = "DELETE\n                     FROM `".concat(table, "`\n                     WHERE `").concat(key, "` = ?");
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated DELETE SQL:", sql);
-                        console.log("[SQL EXECUTOR] \uD83D\uDD22 Value:", args[key]);
-                        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.execute(sql, [args[key]])];
-                                        case 1:
-                                            result = (_a.sent())[0];
-                                            return [2 /*return*/, {
-                                                    rest: result,
-                                                    sql: {
-                                                        sql: sql,
-                                                        args: args
-                                                    }
-                                                }];
-                                    }
-                                });
-                            }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
     SqlExecutor.prototype.formatSQLWithParams = function (sql, params) {
         var _this = this;
         if (Array.isArray(params)) {
@@ -1724,6 +1669,62 @@ var SqlExecutor = /** @class */ (function (_super) {
             return "'".concat(val.toISOString().slice(0, 19).replace('T', ' '), "'");
         return "'".concat(JSON.stringify(val), "'");
     };
+    SqlExecutor.prototype.runQuery = function (type, table, args) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var builder, QueryResult, formatted, toUnnamed, _a, sql, values;
+            var _this = this;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        switch (type) {
+                            case 'select':
+                                builder = new SelectQueryBuilder(this.config, this.request);
+                                break;
+                            case 'update':
+                                builder = new UpdateQueryBuilder(this.config, this.request);
+                                break;
+                            case 'delete':
+                                builder = new DeleteQueryBuilder(this.config, this.request);
+                                break;
+                            default:
+                                throw new Error("Unsupported query type: ".concat(type));
+                        }
+                        QueryResult = builder.build(table, args);
+                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(type.toUpperCase(), " SQL:"), QueryResult);
+                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
+                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(type.toUpperCase(), " SQL:"), formatted);
+                        toUnnamed = namedPlaceholders();
+                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
+                        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 (type === 'select') {
+                                                console.log("[SQL EXECUTOR] \uD83D\uDCE6 Rows fetched:", result);
+                                                return [2 /*return*/, {
+                                                        rest: result.map(this.serialize),
+                                                        sql: { sql: sql, values: values }
+                                                    }];
+                                            }
+                                            else {
+                                                console.log("[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
+                                                return [2 /*return*/, {
+                                                        affected: result.affectedRows,
+                                                        rest: [],
+                                                        sql: { sql: sql, values: values }
+                                                    }];
+                                            }
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
     return SqlExecutor;
 }(Executor));
 
@@ -1738,7 +1739,7 @@ function ExpressHandler(_a) {
     var _this = this;
     var C6 = _a.C6, mysqlPool = _a.mysqlPool;
     return function (req, res, next) { return tslib.__awaiter(_this, void 0, void 0, function () {
-        var method, table, primary, payload, response, err_1;
+        var method, table, primary, payload, primaryKeys, primaryKeyName, response, err_1;
         return tslib.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -1751,18 +1752,36 @@ function ExpressHandler(_a) {
                         res.status(400).json({ error: "Invalid table: ".concat(table) });
                         return [2 /*return*/];
                     }
+                    primaryKeys = C6.TABLES[table].PRIMARY;
+                    if (primary && primaryKeys.length !== 1) {
+                        if (primaryKeys.length > 1) {
+                            res.status(400).json({ error: "Table ".concat(table, " has multiple primary keys. Cannot implicitly determine key.") });
+                            return [2 /*return*/];
+                        }
+                        res.status(400).json({
+                            error: "Table ".concat(table, " has no primary keys. Please specify one.")
+                        });
+                        return [2 /*return*/];
+                    }
+                    primaryKeyName = primaryKeys[0];
                     // 👇 Call restRequest for the resolved method
                     // TODO - add primary conditionally based on method signature
                     switch (method) {
                         case 'GET':
                             if (primary) {
-                                payload['primary'] = primary;
+                                payload[C6C.WHERE][primaryKeyName] = primary;
                             }
                             break;
-                        case 'POST':
                         case 'PUT':
                         case 'DELETE':
-                            payload['primary'] = primary;
+                            if (primary) {
+                                payload[C6C.WHERE][primaryKeyName] = primary;
+                            }
+                            else {
+                                res.status(400).json({ error: "Invalid request: ".concat(method, " requires a primary key.") });
+                            }
+                            break;
+                        case 'POST':
                             break;
                         default:
                             res.status(405).json({ error: "Method ".concat(method, " not allowed") });
@@ -1809,65 +1828,6 @@ var distSphere = function (fromCol, toCol, fromAlias, toAlias) {
     return [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
 };
 
-var DeleteQueryBuilder = /** @class */ (function (_super) {
-    tslib.__extends(DeleteQueryBuilder, _super);
-    function DeleteQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DeleteQueryBuilder.prototype.build = function (table, args) {
-        if (args === void 0) { args = {}; }
-        var params = this.useNamedParams ? {} : [];
-        var sql = args.JOIN ? "DELETE ".concat(table, "\n                               FROM `").concat(table, "`") : "DELETE\n                                                     FROM `".concat(table, "`");
-        if (args.JOIN) {
-            sql += this.buildJoinClauses(args.JOIN, params);
-        }
-        if (args.WHERE) {
-            sql += this.buildWhereClause(args.WHERE, params);
-        }
-        if (args.PAGINATION) {
-            sql += this.buildPaginationClause(args.PAGINATION);
-        }
-        return { sql: sql, params: params };
-    };
-    return DeleteQueryBuilder;
-}(PaginationBuilder));
-
-var UpdateQueryBuilder = /** @class */ (function (_super) {
-    tslib.__extends(UpdateQueryBuilder, _super);
-    function UpdateQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    UpdateQueryBuilder.prototype.build = function (table, data, args) {
-        if (args === void 0) { args = {}; }
-        var params = this.useNamedParams ? {} : [];
-        var sql = "UPDATE `".concat(table, "`");
-        if (args.JOIN) {
-            sql += this.buildJoinClauses(args.JOIN, params);
-        }
-        var setClauses = Object.entries(data).map(function (_a) {
-            var col = _a[0], val = _a[1];
-            if (Array.isArray(params)) {
-                params.push(val);
-                return "`".concat(col, "` = ?");
-            }
-            else {
-                var key = "param".concat(Object.keys(params).length);
-                params[key] = val;
-                return "`".concat(col, "` = :").concat(key);
-            }
-        });
-        sql += " SET ".concat(setClauses.join(', '));
-        if (args.WHERE) {
-            sql += this.buildWhereClause(args.WHERE, params);
-        }
-        if (args.PAGINATION) {
-            sql += this.buildPaginationClause(args.PAGINATION);
-        }
-        return { sql: sql, params: params };
-    };
-    return UpdateQueryBuilder;
-}(PaginationBuilder));
-
 function determineRuntimeJsType(mysqlType) {
     var base = mysqlType.toLowerCase().split('(')[0];
     if ([