@carbonorm/carbonnode 3.4.0 → 3.4.2

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,26 +1,17 @@
 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;
     };
-    insert(table: G['RestShortTableName'], data: Record<string, any>): Promise<{
-        rest: ResultSetHeader;
-        sql: {
-            sql: string;
-            placeholders: string;
-        };
-    }>;
     formatSQLWithParams(sql: string, params: any[] | {
         [key: string]: any;
     }): string;
     private formatValue;
-    runQuery(type: QueryType, table: G['RestShortTableName'], args: any): Promise<{
+    runQuery(): Promise<{
         rest: any;
         sql: {
             sql: any;
@@ -36,4 +27,3 @@ export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
         };
     }>;
 }
-export {};

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

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

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

@@ -0,0 +1,9 @@
+import { ConditionBuilder } from "../builders/ConditionBuilder";
+import { OrmGenerics } from "../../types/ormGenerics";
+export declare class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G> {
+    private trimTablePrefix;
+    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',
@@ -1373,20 +1374,60 @@ var DeleteQueryBuilder = /** @class */ (function (_super) {
     function DeleteQueryBuilder() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    DeleteQueryBuilder.prototype.build = function (table, args) {
+    DeleteQueryBuilder.prototype.build = function (table) {
         var params = this.useNamedParams ? {} : [];
         var sql = "DELETE `".concat(table, "` FROM `").concat(table, "`");
-        if (args.JOIN) {
-            sql += this.buildJoinClauses(args.JOIN, params);
+        if (this.request.JOIN) {
+            sql += this.buildJoinClauses(this.request.JOIN, params);
         }
-        if (args.WHERE) {
-            sql += this.buildWhereClause(args.WHERE, 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.trimTablePrefix = function (table, column) {
+        if (!column.includes('.'))
+            return column;
+        var _a = column.split('.', 2), prefix = _a[0], col = _a[1];
+        if (prefix !== table) {
+            throw new Error("Invalid prefixed column: '".concat(column, "'. Expected prefix '").concat(table, ".'"));
+        }
+        return col;
+    };
+    PostQueryBuilder.prototype.build = function (table) {
+        var _this = this;
+        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, "` (\n            ").concat(keys.map(function (k) { return "`".concat(_this.trimTablePrefix(table, k), "`"); }).join(', '), "\n         ) VALUES (\n            ").concat(placeholders.join(', '), "\n        )");
+        if (C6C.UPDATE in this.request) {
+            var updateData = this.request[C6C.UPDATE];
+            if (!Array.isArray(updateData)) {
+                throw new Error("Update data must be an array of keys to update, got: ".concat(JSON.stringify(updateData)));
+            }
+            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() {
@@ -1447,10 +1488,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
@@ -1476,7 +1518,7 @@ 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 };
     };
@@ -1488,24 +1530,20 @@ var UpdateQueryBuilder = /** @class */ (function (_super) {
     function UpdateQueryBuilder() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    UpdateQueryBuilder.prototype.build = function (table, data, args) {
-        if (args === void 0) { args = {}; }
+    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);
         }
-        var setClauses = Object.entries(data).map(function (_a) {
+        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];
-            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);
-            }
+            return _this.addParam(params, col, val);
         });
         sql += " SET ".concat(setClauses.join(', '));
         if (args.WHERE) {
@@ -1547,23 +1585,23 @@ var SqlExecutor = /** @class */ (function (_super) {
                             case 'DELETE': return [3 /*break*/, 7];
                         }
                         return [3 /*break*/, 9];
-                    case 1: return [4 /*yield*/, this.runQuery('select', TABLE_NAME, 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.runQuery('update', TABLE_NAME, this.request)];
+                    case 5: return [4 /*yield*/, this.runQuery()];
                     case 6:
                         result = _b.sent();
                         updated = tslib.__assign(tslib.__assign({}, result), { updated: true, rowCount: result.rest.affectedRows });
                         return [2 /*return*/, updated];
-                    case 7: return [4 /*yield*/, this.runQuery('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);
@@ -1603,41 +1641,6 @@ var SqlExecutor = /** @class */ (function (_super) {
             });
         });
     };
-    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.formatSQLWithParams = function (sql, params) {
         var _this = this;
         if (Array.isArray(params)) {
@@ -1669,30 +1672,35 @@ 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) {
+    SqlExecutor.prototype.runQuery = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var builder, QueryResult, formatted, toUnnamed, _a, sql, values;
+            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:
-                        switch (type) {
-                            case 'select':
+                        TABLE_NAME = this.config.restModel.TABLE_NAME;
+                        method = this.config.requestMethod;
+                        switch (method) {
+                            case 'GET':
                                 builder = new SelectQueryBuilder(this.config, this.request);
                                 break;
-                            case 'update':
+                            case 'PUT':
                                 builder = new UpdateQueryBuilder(this.config, this.request);
                                 break;
-                            case 'delete':
+                            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 type: ".concat(type));
+                                throw new Error("Unsupported query method: ".concat(method));
                         }
-                        QueryResult = builder.build(table, args);
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(type.toUpperCase(), " SQL:"), QueryResult);
+                        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(type.toUpperCase(), " SQL:"), formatted);
+                        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 () {
@@ -1702,7 +1710,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                                         case 0: return [4 /*yield*/, conn.query(sql, values)];
                                         case 1:
                                             result = (_a.sent())[0];
-                                            if (type === 'select') {
+                                            if (method === 'GET') {
                                                 console.log("[SQL EXECUTOR] \uD83D\uDCE6 Rows fetched:", result);
                                                 return [2 /*return*/, {
                                                         rest: result.map(this.serialize),
@@ -1942,6 +1950,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;