@carbonorm/carbonnode 3.0.15 → 3.1.3

package/src/api/executors/HttpExecutor.ts

@@ -5,6 +5,7 @@ import isTest from "../../variables/isTest";
 import isVerbose from "../../variables/isVerbose";
 import convertForRequestBody from "../convertForRequestBody";
 import {eFetchDependencies} from "../types/dynamicFetching";
+import {OrmGenerics} from "../types/ormGenerics";
 import {
     apiReturn,
     DELETE, DetermineResponseDataType,
@@ -12,7 +13,6 @@ import {
     iCacheAPI,
     iConstraint,
     iGetC6RestResponse,
-    iRestMethods,
     POST,
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
@@ -23,36 +23,24 @@ import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
 
 export class HttpExecutor<
-    RequestMethod extends iRestMethods,
-    RestShortTableName extends string = any,
-    RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
-    CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+    G extends OrmGenerics
 >
-    extends Executor<
-        RequestMethod,
-        RestShortTableName,
-        RestTableInterface,
-        PrimaryKey,
-        CustomAndRequiredFields,
-        RequestTableOverrides
-    > {
+    extends Executor<G> {
 
     public putState(
-        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
-        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
-                removeInvalidKeys<RestTableInterface>({
+                removeInvalidKeys<G['RestTableInterface']>({
                     ...request,
                     ...response?.data?.rest,
                 }, this.config.C6.TABLES)
@@ -63,12 +51,12 @@ export class HttpExecutor<
     }
 
     public postState(
-        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
@@ -87,49 +75,49 @@ export class HttpExecutor<
 
         }
 
-        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: undefined !== request.dataInsertMultipleRows
                 ? request.dataInsertMultipleRows.map((request, index) => {
-                    return removeInvalidKeys<RestTableInterface>({
+                    return removeInvalidKeys<G['RestTableInterface']>({
                         ...request,
                         ...(index === 0 ? response?.data?.rest : {}),
                     }, this.config.C6.TABLES)
                 })
                 : [
-                    removeInvalidKeys<RestTableInterface>({
+                    removeInvalidKeys<G['RestTableInterface']>({
                         ...request,
                         ...response?.data?.rest,
                     }, this.config.C6.TABLES)
                 ],
             stateKey: this.config.restModel.TABLE_NAME,
-            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[]
         })
     }
 
     public deleteState(
-        _response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        _response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
         callback: () => void
     ) {
-        this.config.reactBootstrap?.deleteRestfulObjectArrays<RestTableInterface>({
+        this.config.reactBootstrap?.deleteRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
-                request as unknown as RestTableInterface,
+                request as unknown as G['RestTableInterface'],
             ],
             stateKey: this.config.restModel.TABLE_NAME,
-            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[]
         })
     }
 
-    public async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
+    public async execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
 
-        type ResponseDataType = DetermineResponseDataType<RequestMethod, RestTableInterface>;
+        type ResponseDataType = DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>;
 
         const {
             C6,
@@ -151,7 +139,7 @@ export class HttpExecutor<
             });
 
 
-        const tableName = restModel.TABLE_NAME;
+        const tableName = restModel.TABLE_NAME as string;
 
         const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
 
@@ -218,7 +206,7 @@ export class HttpExecutor<
         }
 
         // this could return itself with a new page number, or undefined if the end is reached
-        const apiRequest = async (): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> => {
+        const apiRequest = async (): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> => {
 
             const {
                 debug,
@@ -261,10 +249,10 @@ export class HttpExecutor<
                     if (undefined === query || null === query) {
 
                         query = {} as RequestQueryBody<
-                            RequestMethod,
-                            RestTableInterface,
-                            CustomAndRequiredFields,
-                            RequestTableOverrides
+                            G['RequestMethod'],
+                            G['RestTableInterface'],
+                            G['CustomAndRequiredFields'],
+                            G['RequestTableOverrides']
                         >
 
                     }
@@ -351,7 +339,7 @@ export class HttpExecutor<
 
             let addBackPK: (() => void) | undefined;
 
-            let apiResponse: RestTableInterface[PrimaryKey] | string | boolean | number | undefined;
+            let apiResponse: G['RestTableInterface'][G['PrimaryKey']] | string | boolean | number | undefined;
 
             let returnGetNextPageFunction = false;
 
@@ -427,10 +415,10 @@ export class HttpExecutor<
 
                 addBackPK = () => {
                     query ??= {} as RequestQueryBody<
-                        RequestMethod,
-                        RestTableInterface,
-                        CustomAndRequiredFields,
-                        RequestTableOverrides
+                        G['RequestMethod'],
+                        G['RestTableInterface'],
+                        G['CustomAndRequiredFields'],
+                        G['RequestTableOverrides']
                     >;
                     query[primaryKey] = removedPkValue;
                 }
@@ -470,10 +458,10 @@ export class HttpExecutor<
                     ...(() => {
                         const convert = (data: any) =>
                             convertForRequestBody<
-                                RequestMethod,
-                                RestTableInterface,
-                                CustomAndRequiredFields,
-                                RequestTableOverrides
+                                G['RequestMethod'],
+                                G['RestTableInterface'],
+                                G['CustomAndRequiredFields'],
+                                G['RequestTableOverrides']
                             >(
                                 data,
                                 fullTableList,
@@ -574,7 +562,6 @@ export class HttpExecutor<
                         if (false === apiResponse) {
 
 
-
                             if (debug && isLocal()) {
 
                                 toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
@@ -596,10 +583,10 @@ export class HttpExecutor<
                         if (undefined !== reactBootstrap && response) {
                             switch (requestMethod) {
                                 case GET:
-                                    reactBootstrap.updateRestfulObjectArrays<RestTableInterface>({
+                                    reactBootstrap.updateRestfulObjectArrays<G['RestTableInterface']>({
                                         dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
                                         stateKey: this.config.restModel.TABLE_NAME,
-                                        uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[],
+                                        uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[],
                                         callback
                                     })
                                     break;

package/src/api/executors/SqlExecutor.ts

@@ -1,34 +1,22 @@
-import {SqlBuilder} from "api/builders/sqlBuilder";
+import {SelectQueryBuilder} from "../orm/queries/SelectQueryBuilder";
+import {OrmGenerics} from "../types/ormGenerics";
 import {
     apiReturn,
     DetermineResponseDataType,
     iPostC6RestResponse,
     iPutC6RestResponse,
-    iDeleteC6RestResponse,
-    iRestMethods
+    iDeleteC6RestResponse
 } from "../types/ormInterfaces";
 import namedPlaceholders from 'named-placeholders';
 import {PoolConnection, RowDataPacket, ResultSetHeader} from 'mysql2/promise';
 import {Buffer} from 'buffer';
+import {Executor} from "./Executor";
 
 export class SqlExecutor<
-    RequestMethod extends iRestMethods,
-    RestShortTableName extends string = any,
-    RestTableInterface extends Record<string, any> = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
-    CustomAndRequiredFields extends Record<string, any> = any,
-    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
-> extends SqlBuilder<
-    RequestMethod,
-    RestShortTableName,
-    RestTableInterface,
-    PrimaryKey,
-    CustomAndRequiredFields,
-    RequestTableOverrides
-> {
-
-
-    async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
+    G extends OrmGenerics
+> extends Executor<G>{
+
+    async execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
         const {TABLE_NAME} = this.config.restModel;
         const method = this.config.requestMethod;
 
@@ -39,14 +27,14 @@ export class SqlExecutor<
             case 'GET': {
                 const rest = await this.select(TABLE_NAME, undefined, this.request);
                 console.log(`[SQL EXECUTOR] ✅ GET result:`, rest);
-                return rest as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return rest as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'POST': {
                 const result = await this.insert(TABLE_NAME, this.request);
                 console.log(`[SQL EXECUTOR] ✅ POST result:`, result);
                 const created: iPostC6RestResponse = {rest: result, created: true};
-                return created as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return created as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'PUT': {
@@ -57,7 +45,7 @@ export class SqlExecutor<
                     updated: true,
                     rowCount: result.rest.affectedRows
                 };
-                return updated as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return updated as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             case 'DELETE': {
@@ -68,7 +56,7 @@ export class SqlExecutor<
                     deleted: true,
                     rowCount: result.rest.affectedRows
                 };
-                return deleted as apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+                return deleted as apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
             }
 
             default:
@@ -92,8 +80,8 @@ export class SqlExecutor<
         ([k, v]) => [k, Buffer.isBuffer(v) ? v.toString('hex').toUpperCase() : v]
     ));
 
-    async select<TName extends string>(table: TName, primary: string | undefined, args: any) {
-        const QueryResult = this.buildSelectQuery<TName>(table, primary, args);
+    async select(table: G['RestShortTableName'], primary: string | undefined, args: any) {
+        const QueryResult = (new SelectQueryBuilder(this.config, this.request)).build(table, args, primary);
         console.log(`[SQL EXECUTOR] 🧠 Generated SELECT SQL:`, QueryResult);
         const formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
         console.log(`[SQL EXECUTOR] 🧠 Formatted SELECT SQL:`, formatted);
@@ -111,7 +99,7 @@ export class SqlExecutor<
         });
     }
 
-    async insert<TName extends string>(table: TName, data: Record<string, any>) {
+    async insert(table: G['RestShortTableName'], data: Record<string, any>) {
         const keys = Object.keys(data);
         const values = keys.map(k => data[k]);
         const placeholders = keys.map(() => '?').join(', ');
@@ -132,7 +120,7 @@ export class SqlExecutor<
         });
     }
 
-    async update<TName extends string>(table: TName, primary: string[], data: Record<string, any>) {
+    async update(table: G['RestShortTableName'], primary: string[], data: Record<string, any>) {
         if (!primary?.length) throw new Error('Primary key is required for update');
         const keys = Object.keys(data);
         const values = keys.map(k => data[k]);
@@ -156,7 +144,7 @@ export class SqlExecutor<
         });
     }
 
-    async delete<TName extends string>(table: TName, primary: string[], args: Record<string, any>) {
+    async delete(table: G['RestShortTableName'], primary: string[], args: Record<string, any>) {
         const key = primary?.[0];
         if (!key || !args?.[key]) throw new Error('Primary key and value required for delete');
         const sql = `DELETE

package/src/api/handlers/ExpressHandler.ts

@@ -49,7 +49,7 @@ export function ExpressHandler({C6, mysqlPool}: { C6: iC6Object, mysqlPool: Pool
             res.status(200).json({success: true, ...response});
 
         } catch (err) {
-            res.status(500).json({success: false});
+            res.status(500).json({success: false, error: err});
             next(err);
         }
     };

package/src/api/orm/builders/AggregateBuilder.ts

@@ -0,0 +1,38 @@
+import isVerbose from "../../../variables/isVerbose";
+import {Executor} from "../../executors/Executor";
+import {OrmGenerics} from "../../types/ormGenerics";
+
+export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G>{
+    buildAggregateField(field: string | any[]): string {
+        if (typeof field === 'string') {
+            return field;
+        }
+
+        if (!Array.isArray(field) || field.length === 0) {
+            throw new Error('Invalid SELECT field entry');
+        }
+
+        let [fn, ...args] = field;
+        let alias: string | undefined;
+
+        if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
+            alias = String(args.pop());
+            args.pop();
+        }
+
+        const F = String(fn).toUpperCase();
+        const argList = args.map(arg =>
+            Array.isArray(arg) ? this.buildAggregateField(arg) : arg
+        ).join(', ');
+
+        let expr = `${F}(${argList})`;
+
+        if (alias) {
+            expr += ` AS ${alias}`;
+        }
+
+        isVerbose() && console.log(`[SELECT] ${expr}`);
+
+        return expr;
+    }
+}

package/src/api/orm/builders/ConditionBuilder.ts

@@ -0,0 +1,113 @@
+import {C6Constants} from "api/C6Constants";
+import isVerbose from "../../../variables/isVerbose";
+import {OrmGenerics} from "../../types/ormGenerics";
+import {apiReturn, DetermineResponseDataType} from "../../types/ormInterfaces";
+import {convertHexIfBinary} from "../utils/sqlUtils";
+import {AggregateBuilder} from "./AggregateBuilder";
+
+export class ConditionBuilder<
+    G extends OrmGenerics
+> extends AggregateBuilder<G> {
+    execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> {
+        throw new Error("Method not implemented.");
+    }
+
+    private readonly OPERATORS = new Set([
+        '=', '!=', '<', '<=', '>', '>=',
+        'LIKE', 'NOT LIKE', 'IN', 'NOT IN',
+        'IS', 'IS NOT', 'BETWEEN', 'NOT BETWEEN',
+        C6Constants.MATCH_AGAINST
+    ]);
+
+    private validateOperator(op: string) {
+        if (!this.OPERATORS.has(op)) {
+            throw new Error(`Invalid or unsupported SQL operator detected: '${op}'`);
+        }
+    }
+
+    private addParam(
+        params: any[] | Record<string, any>,
+        column: string,
+        value: any
+    ): string {
+        const columnDef = this.config.C6[column.split('.')[0]]?.TYPE_VALIDATION?.[column];
+        const val = convertHexIfBinary(column, value, columnDef);
+
+        if (this.useNamedParams) {
+            const key = `param${Object.keys(params).length}`;
+            (params as Record<string, any>)[key] = val;
+            return `:${key}`;
+        } else {
+            (params as any[]).push(val);
+            return '?';
+        }
+    }
+
+    buildBooleanJoinedConditions(
+        set: any,
+        andMode: boolean = true,
+        params: any[] | Record<string, any> = []
+    ): string {
+        const booleanOperator = andMode ? 'AND' : 'OR';
+
+        const addCondition = (column: string, op: string, value: any): string => {
+            this.validateOperator(op);
+
+
+            if (op === C6Constants.MATCH_AGAINST && Array.isArray(value)) {
+                const [search, mode] = value;
+                const paramName = this.useNamedParams ? `param${Object.keys(params).length}` : null;
+                if (this.useNamedParams) {
+                    params[paramName!] = search;
+                } else {
+                    params.push(search);
+                }
+
+                let againstClause: string;
+
+                switch ((mode || '').toUpperCase()) {
+                    case 'BOOLEAN':
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} IN BOOLEAN MODE)` : `AGAINST(? IN BOOLEAN MODE)`;
+                        break;
+                    case 'WITH QUERY EXPANSION':
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} WITH QUERY EXPANSION)` : `AGAINST(? WITH QUERY EXPANSION)`;
+                        break;
+                    default: // NATURAL or undefined
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName})` : `AGAINST(?)`;
+                        break;
+                }
+
+                const matchClause = `(MATCH(${column}) ${againstClause})`;
+                isVerbose() && console.log(`[MATCH_AGAINST] ${matchClause}`);
+                return matchClause;
+            }
+
+            // handle other operators
+            return `( ${column} ${op} ${this.addParam(params, column, value)} )`;
+        };
+
+        const parts: string[] = [];
+
+        if (typeof set === 'object' && !Array.isArray(set)) {
+            for (const [key, value] of Object.entries(set)) {
+                if (typeof value === 'object' && value !== null && Object.keys(value).length === 1) {
+                    const [op, val] = Object.entries(value)[0];
+                    parts.push(addCondition(key, op, val));
+                } else {
+                    parts.push(addCondition(key, '=', value));
+                }
+            }
+        }
+
+        const clause = parts.join(` ${booleanOperator} `);
+        return clause ? `(${clause})` : '';
+    }
+
+    buildWhereClause(whereArg: any, params: any[] | Record<string, any>): string {
+        const clause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        if (!clause) return '';
+        const trimmed = clause.replace(/^\((.*)\)$/, '$1');
+        isVerbose() && console.log(`[WHERE] ${trimmed}`);
+        return ` WHERE ${trimmed}`;
+    }
+}

package/src/api/orm/builders/JoinBuilder.ts

@@ -0,0 +1,25 @@
+import isVerbose from "../../../variables/isVerbose";
+import {OrmGenerics} from "../../types/ormGenerics";
+import {ConditionBuilder} from "./ConditionBuilder";
+
+export class JoinBuilder<G extends OrmGenerics> extends ConditionBuilder<G>{
+
+    buildJoinClauses(joinArgs: any, params: any[] | Record<string, any>): string {
+        let sql = '';
+
+        for (const joinType in joinArgs) {
+            const joinKind = joinType.replace('_', ' ').toUpperCase();
+
+            for (const raw in joinArgs[joinType]) {
+                const [table, alias] = raw.split(' ');
+                const onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
+                const joinSql = alias ? `\`${table}\` AS \`${alias}\`` : `\`${table}\``;
+                sql += ` ${joinKind} JOIN ${joinSql} ON ${onClause}`;
+            }
+        }
+
+        isVerbose() && console.log(`[JOIN] ${sql.trim()}`);
+
+        return sql;
+    }
+}

package/src/api/orm/builders/PaginationBuilder.ts

@@ -0,0 +1,56 @@
+import {C6Constants} from "api/C6Constants";
+import isVerbose from "../../../variables/isVerbose";
+import {OrmGenerics} from "../../types/ormGenerics";
+import {JoinBuilder} from "./JoinBuilder";
+
+export class PaginationBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
+
+    /**
+     * MySQL ORDER/LIMIT/OFFSET generator.
+     *
+     * Accepted structures:
+     * ```ts
+     * ORDER: {
+     *   // simple column with direction
+     *   [property_units.UNIT_ID]: "DESC",
+     *	 // function call (array of arguments)
+     *   [C6Constants.ST_DISTANCE_SPHERE]: [property_units.LOCATION, F(property_units.LOCATION, "pu_target")]
+     * }
+     * ```
+     */
+    buildPaginationClause(pagination: any): string {
+        let sql = "";
+
+        /* -------- ORDER BY -------- */
+        if (pagination?.[C6Constants.ORDER]) {
+            const orderParts: string[] = [];
+
+            for (const [key, val] of Object.entries(pagination[C6Constants.ORDER])) {
+                // FUNCTION CALL: val is an array of args
+                if (Array.isArray(val)) {
+                    const args = val
+                        .map((arg) => Array.isArray(arg) ? this.buildAggregateField(arg) : String(arg))
+                        .join(", ");
+                    orderParts.push(`${key}(${args})`);
+                }
+                // SIMPLE COLUMN + DIR (ASC/DESC)
+                else {
+                    orderParts.push(`${key} ${String(val).toUpperCase()}`);
+                }
+            }
+
+            if (orderParts.length) sql += ` ORDER BY ${orderParts.join(", ")}`;
+        }
+
+        /* -------- LIMIT / OFFSET -------- */
+        if (pagination?.[C6Constants.LIMIT] != null) {
+            const lim = parseInt(pagination[C6Constants.LIMIT], 10);
+            const page = parseInt(pagination[C6Constants.PAGE] ?? 1, 10);
+            const offset = (page - 1) * lim;
+            sql += ` LIMIT ${offset}, ${lim}`;
+        }
+
+        isVerbose() && console.log(`[PAGINATION] ${sql.trim()}`);
+        return sql;
+    }
+}

package/src/api/orm/queries/DeleteQueryBuilder.ts

@@ -0,0 +1,28 @@
+import {OrmGenerics} from "../../types/ormGenerics";
+import {PaginationBuilder} from "../builders/PaginationBuilder";
+import {SqlBuilderResult} from "../utils/sqlUtils";
+
+export class DeleteQueryBuilder<G extends OrmGenerics>
+    extends PaginationBuilder<G> {
+
+    build(table: string, args: any = {}): SqlBuilderResult {
+        const params = this.useNamedParams ? {} : [];
+        let sql = args.JOIN ? `DELETE ${table}
+                               FROM \`${table}\`` : `DELETE
+                                                     FROM \`${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, params};
+    }
+}

package/src/api/orm/queries/SelectQueryBuilder.ts

@@ -0,0 +1,49 @@
+import {OrmGenerics} from "../../types/ormGenerics";
+import {PaginationBuilder} from "../builders/PaginationBuilder";
+import {SqlBuilderResult} from "../utils/sqlUtils";
+
+export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
+
+    build(
+        table: string,
+        args: any,
+        primary?: string,
+        isSubSelect: boolean = false
+    ): SqlBuilderResult {
+        const params = this.useNamedParams ? {} : [];
+
+        const selectList = args.SELECT ?? ['*'];
+        const selectFields = selectList
+            .map((f: any) => this.buildAggregateField(f))
+            .join(', ');
+
+        let sql = `SELECT ${selectFields} FROM \`${table}\``;
+
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+
+        if (args.GROUP_BY) {
+            const groupBy = Array.isArray(args.GROUP_BY)
+                ? args.GROUP_BY.join(', ')
+                : args.GROUP_BY;
+            sql += ` GROUP BY ${groupBy}`;
+        }
+
+        if (args.HAVING) {
+            sql += ` HAVING ${this.buildBooleanJoinedConditions(args.HAVING, true, params)}`;
+        }
+
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        } else if (!isSubSelect) {
+            sql += primary ? ` ORDER BY ${primary} ASC LIMIT 1` : ` LIMIT 100`;
+        }
+
+        return { sql, params };
+    }
+}