@carbonorm/carbonnode 3.3.10 → 3.4.1

package/dist/api/C6Constants.d.ts

@@ -140,6 +140,7 @@ export declare const C6Constants: {
     YEARWEEK: string;
     DEPENDANT_ON_ENTITY: string;
     OPTIONS: string;
+    INSERT: string;
     GET: string;
     POST: string;
     PUT: string;
@@ -293,6 +294,7 @@ export declare const C6C: {
     YEARWEEK: string;
     DEPENDANT_ON_ENTITY: string;
     OPTIONS: string;
+    INSERT: string;
     GET: string;
     POST: string;
     PUT: string;

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

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

package/dist/api/orm/builders/ConditionBuilder.d.ts

@@ -1,11 +1,13 @@
 import { OrmGenerics } from "../../types/ormGenerics";
 import { DetermineResponseDataType } from "../../types/ormInterfaces";
+import { SqlBuilderResult } from "../utils/sqlUtils";
 import { AggregateBuilder } from "./AggregateBuilder";
-export declare class ConditionBuilder<G extends OrmGenerics> extends AggregateBuilder<G> {
+export declare abstract class ConditionBuilder<G extends OrmGenerics> extends AggregateBuilder<G> {
+    abstract build(table: string): SqlBuilderResult;
     execute(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
     private readonly OPERATORS;
     private validateOperator;
-    private addParam;
+    addParam(params: any[] | Record<string, any>, column: string, value: any): string;
     buildBooleanJoinedConditions(set: any, andMode?: boolean, params?: any[] | Record<string, any>): string;
     buildWhereClause(whereArg: any, params: any[] | Record<string, any>): string;
 }

package/dist/api/orm/builders/JoinBuilder.d.ts

@@ -1,5 +1,5 @@
 import { OrmGenerics } from "../../types/ormGenerics";
 import { ConditionBuilder } from "./ConditionBuilder";
-export declare class JoinBuilder<G extends OrmGenerics> extends ConditionBuilder<G> {
+export declare abstract class JoinBuilder<G extends OrmGenerics> extends ConditionBuilder<G> {
     buildJoinClauses(joinArgs: any, params: any[] | Record<string, any>): string;
 }

package/dist/api/orm/builders/PaginationBuilder.d.ts

@@ -1,6 +1,6 @@
 import { OrmGenerics } from "../../types/ormGenerics";
 import { JoinBuilder } from "./JoinBuilder";
-export declare class PaginationBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
+export declare abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
     /**
      * MySQL ORDER/LIMIT/OFFSET generator.
      *

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

@@ -1,6 +1,6 @@
 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): SqlBuilderResult;
 }

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

@@ -0,0 +1,8 @@
+import { ConditionBuilder } from "../builders/ConditionBuilder";
+import { OrmGenerics } from "../../types/ormGenerics";
+export declare class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G> {
+    build(table: string): {
+        sql: string;
+        params: any[];
+    };
+}

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

@@ -2,5 +2,5 @@ import { OrmGenerics } from "../../types/ormGenerics";
 import { PaginationBuilder } from "../builders/PaginationBuilder";
 import { SqlBuilderResult } from "../utils/sqlUtils";
 export declare class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G> {
-    build(table: string, args: any, primary?: string, isSubSelect?: boolean): SqlBuilderResult;
+    build(table: string, isSubSelect?: boolean): SqlBuilderResult;
 }

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

@@ -2,5 +2,5 @@ import { OrmGenerics } from "../../types/ormGenerics";
 import { PaginationBuilder } from '../builders/PaginationBuilder';
 import { SqlBuilderResult } from "../utils/sqlUtils";
 export declare class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G> {
-    build(table: string, data: Record<string, any>, args?: any): SqlBuilderResult;
+    build(table: string): SqlBuilderResult;
 }

package/dist/api/types/ormInterfaces.d.ts

@@ -82,7 +82,7 @@ export type RequestQueryBody<Method extends iRestMethods, T extends {
     [key: string]: any;
 } = {}, Overrides extends {
     [key: string]: any;
-} = {}> = Method extends 'GET' | 'PUT' | 'DELETE' ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>> : iAPI<Modify<T, Overrides> & Custom>;
+} = {}> = Method extends 'GET' | 'PUT' | 'DELETE' ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>> : Method extends 'POST' ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom> & Modify<T, Overrides> & Custom> : iAPI<Modify<T, Overrides> & Custom>;
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;
     request: AxiosPromise<ResponseDataType>;

package/dist/index.cjs.js

@@ -154,6 +154,7 @@ var C6Constants = {
     DEPENDANT_ON_ENTITY: 'DEPENDANT_ON_ENTITY',
     // PHP validation
     OPTIONS: 'OPTIONS',
+    INSERT: 'INSERT',
     GET: 'GET',
     POST: 'POST',
     PUT: 'PUT',
@@ -1368,6 +1369,52 @@ 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) {
+        var params = this.useNamedParams ? {} : [];
+        var sql = "DELETE `".concat(table, "` FROM `").concat(table, "`");
+        if (this.request.JOIN) {
+            sql += this.buildJoinClauses(this.request.JOIN, params);
+        }
+        if (this.request.WHERE) {
+            sql += this.buildWhereClause(this.request.WHERE, params);
+        }
+        return { sql: sql, params: params };
+    };
+    return DeleteQueryBuilder;
+}(JoinBuilder));
+
+var PostQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(PostQueryBuilder, _super);
+    function PostQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PostQueryBuilder.prototype.build = function (table) {
+        var verb = C6C.REPLACE in this.request ? C6C.REPLACE : C6C.INSERT;
+        var keys = Object.keys(verb in this.request ? this.request[verb] : this.request);
+        var params = [];
+        var placeholders = [];
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            var value = this.request[key];
+            var placeholder = this.addParam(params, key, value);
+            placeholders.push(placeholder);
+        }
+        var sql = "".concat(verb, " INTO `").concat(table, "` (").concat(keys.map(function (k) { return "`".concat(k, "`"); }).join(', '), ")\nVALUES (").concat(placeholders.join(', '), ")");
+        if (C6C.UPDATE in this.request) {
+            var updateData = this.request[C6C.UPDATE];
+            var updateClause = updateData.map(function (k) { return "`".concat(k, "` = VALUES(`").concat(k, "`)"); }).join(', ');
+            sql += " ON DUPLICATE KEY UPDATE ".concat(updateClause);
+        }
+        return { sql: sql, params: params };
+    };
+    return PostQueryBuilder;
+}(ConditionBuilder));
+
 var PaginationBuilder = /** @class */ (function (_super) {
     tslib.__extends(PaginationBuilder, _super);
     function PaginationBuilder() {
@@ -1428,10 +1475,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
     function SelectQueryBuilder() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    SelectQueryBuilder.prototype.build = function (table, args, primary, isSubSelect) {
+    SelectQueryBuilder.prototype.build = function (table, isSubSelect) {
         var _this = this;
         var _a;
         if (isSubSelect === void 0) { isSubSelect = false; }
+        var args = this.request;
         var params = this.useNamedParams ? {} : [];
         var selectList = (_a = args.SELECT) !== null && _a !== void 0 ? _a : ['*'];
         var selectFields = selectList
@@ -1457,13 +1505,45 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             sql += this.buildPaginationClause(args.PAGINATION);
         }
         else if (!isSubSelect) {
-            sql += primary ? " ORDER BY ".concat(primary, " ASC LIMIT 1") : " LIMIT 100";
+            sql += " LIMIT 100";
         }
         return { sql: sql, params: params };
     };
     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) {
+        var _this = this;
+        var args = this.request;
+        var params = this.useNamedParams ? {} : [];
+        var sql = "UPDATE `".concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        if (!(C6C.UPDATE in this.request)) {
+            throw new Error("No update data provided in the request.");
+        }
+        var setClauses = Object.entries(this.request[C6C.UPDATE]).map(function (_a) {
+            var col = _a[0], val = _a[1];
+            return _this.addParam(params, col, val);
+        });
+        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,24 +1572,23 @@ 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()];
                     case 2:
                         rest = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 GET result:", rest);
                         return [2 /*return*/, rest];
-                    case 3: return [4 /*yield*/, this.insert(TABLE_NAME, this.request)];
+                    case 3: return [4 /*yield*/, this.runQuery()];
                     case 4:
                         result = _b.sent();
                         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()];
                     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()];
                     case 8:
                         result = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 DELETE result:", result);
@@ -1549,150 +1628,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;
-            var _this = this;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        keys = Object.keys(data);
-                        values = keys.map(function (k) { return data[k]; });
-                        placeholders = keys.map(function () { return '?'; }).join(', ');
-                        sql = "INSERT INTO `".concat(table, "` (").concat(keys.join(', '), ")\n                     VALUES (").concat(placeholders, ")");
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated INSERT 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,
-                                                        placeholders: placeholders
-                                                    }
-                                                }];
-                                    }
-                                });
-                            }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    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 +1659,67 @@ var SqlExecutor = /** @class */ (function (_super) {
             return "'".concat(val.toISOString().slice(0, 19).replace('T', ' '), "'");
         return "'".concat(JSON.stringify(val), "'");
     };
+    SqlExecutor.prototype.runQuery = function () {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var TABLE_NAME, method, builder, QueryResult, formatted, toUnnamed, _a, sql, values;
+            var _this = this;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.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);
+                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), QueryResult);
+                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
+                        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.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') {
+                                                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 +1734,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 +1747,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 +1823,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 ([
@@ -1982,6 +1937,7 @@ exports.JoinBuilder = JoinBuilder;
 exports.POST = POST;
 exports.PUT = PUT;
 exports.PaginationBuilder = PaginationBuilder;
+exports.PostQueryBuilder = PostQueryBuilder;
 exports.SelectQueryBuilder = SelectQueryBuilder;
 exports.SqlExecutor = SqlExecutor;
 exports.TestRestfulResponse = TestRestfulResponse;