@carbonorm/carbonnode 3.0.13 → 3.1.2

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,28 @@
+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> {
+
+    buildPaginationClause(pagination: any): string {
+        let sql = '';
+
+        if (pagination?.[C6Constants.ORDER]) {
+            const orderParts = Object.entries(pagination[C6Constants.ORDER])
+                .map(([col, dir]) => `${Array.isArray(col) ? this.buildAggregateField(col) : col} ${String(dir).toUpperCase()}`);
+            sql += ` ORDER BY ${orderParts.join(', ')}`;
+        }
+
+        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 };
+    }
+}

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

@@ -0,0 +1,42 @@
+import {OrmGenerics} from "../../types/ormGenerics";
+import { PaginationBuilder } from '../builders/PaginationBuilder';
+import {SqlBuilderResult} from "../utils/sqlUtils";
+
+export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
+
+    build(
+        table: string,
+        data: Record<string, any>,
+        args: any = {}
+    ): SqlBuilderResult {
+        const params = this.useNamedParams ? {} : [];
+        let sql = `UPDATE \`${table}\``;
+
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+
+        const setClauses = Object.entries(data).map(([col, val]) => {
+            if (Array.isArray(params)) {
+                params.push(val);
+                return `\`${col}\` = ?`;
+            } else {
+                const key = `param${Object.keys(params).length}`;
+                params[key] = val;
+                return `\`${col}\` = :${key}`;
+            }
+        });
+
+        sql += ` SET ${setClauses.join(', ')}`;
+
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        }
+
+        return { sql, params };
+    }
+}

package/src/api/orm/queryHelpers.ts

@@ -0,0 +1,18 @@
+// Alias a table name with a given alias
+import {C6C} from "../C6Constants";
+
+export const A = (tableName: string, alias: string): string =>
+    `${tableName} ${alias}`;
+
+// Qualify a column constant (e.g. 'property_units.parcel_id') to an alias
+export const F = (qualifiedCol: string, alias: string): string =>
+    `${alias}.${qualifiedCol.split('.').pop()}`;
+
+// Equal join condition using full-qualified column constants
+export const fieldEq = (leftCol: string, rightCol: string, leftAlias: string, rightAlias: string): Record<string, string> => ({
+    [F(leftCol, leftAlias)]: F(rightCol, rightAlias)
+});
+
+// ST_Distance_Sphere for aliased fields
+export const distSphere = (fromCol: string, toCol: string, fromAlias: string, toAlias: string): any[] =>
+    [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];

package/src/api/orm/utils/sqlUtils.ts

@@ -0,0 +1,24 @@
+
+
+
+export interface SqlBuilderResult {
+    sql: string;
+    params: any[] | { [key: string]: any };  // params can be an array or an object for named placeholders
+}
+
+
+export function convertHexIfBinary(
+    _col: string,
+    val: any,
+    columnDef?: any
+): any {
+    if (
+        typeof val === 'string' &&
+        /^[0-9a-fA-F]{32}$/.test(val) &&
+        typeof columnDef === 'object' &&
+        columnDef.MYSQL_TYPE.toUpperCase().includes('BINARY')
+    ) {
+        return Buffer.from(val, 'hex');
+    }
+    return val;
+}

package/src/api/restOrm.ts

@@ -1,27 +1,17 @@
 import restRequest from "./restRequest";
+import {OrmGenerics} from "./types/ormGenerics";
 import { iRest, iRestMethods } from "./types/ormInterfaces";
 
 export function restOrm<
-    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 }
->(config: () => Omit<iRest<RestShortTableName, RestTableInterface, PrimaryKey>, "requestMethod">) {
+    G extends Omit<OrmGenerics, "requestMethod">
+>(config: () => Omit<iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>, "requestMethod">) {
 
     const methods: iRestMethods[] = ["GET", "PUT", "POST", "DELETE"];
 
     return Object.fromEntries(
         methods.map(method => [
             method[0] + method.slice(1).toLowerCase(), // Capitalize e.g. "Get"
-            restRequest<
-                typeof method,
-                RestShortTableName,
-                RestTableInterface,
-                PrimaryKey,
-                CustomAndRequiredFields,
-                RequestTableOverrides
-            >(() => ({
+            restRequest<G>(() => ({
                 ...config(),
                 requestMethod: method as iRestMethods,
             }))

package/src/api/restRequest.ts

@@ -1,65 +1,47 @@
 import isNode from '../variables/isNode';
+import {OrmGenerics} from "./types/ormGenerics";
 import {
     apiReturn, DetermineResponseDataType,
-    iRest, iRestMethods, RequestQueryBody
+    iRest, RequestQueryBody
 } from "./types/ormInterfaces";
 
 /**
  * Facade: routes API calls to SQL or HTTP executors based on runtime context.
  */
 export default function restRequest<
-    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
 >(
     configX: (() => iRest<
-        RestShortTableName,
-        RestTableInterface,
-        PrimaryKey
+        G['RestTableInterface'],
+        G['RestShortTableName'],
+        G['PrimaryKey']
     >) | iRest<
-        RestShortTableName,
-        RestTableInterface,
-        PrimaryKey
+        G['RestShortTableName'],
+        G['RestTableInterface'],
+        G['PrimaryKey']
     >
 ) {
     return async (
         request: RequestQueryBody<
-            RequestMethod,
-            RestTableInterface,
-            CustomAndRequiredFields,
-            RequestTableOverrides
+            G['RequestMethod'],
+            G['RestTableInterface'],
+            G['CustomAndRequiredFields'],
+            G['RequestTableOverrides']
         >,
-    ): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> => {
+    ): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>> => {
 
         const config = typeof configX === "function" ? configX() : configX;
 
         // SQL path if on Node with a provided pool
         if (isNode() && config.mysqlPool) {
             const {SqlExecutor} = await import('./executors/SqlExecutor');
-            const executor = new SqlExecutor<
-                RequestMethod,
-                RestShortTableName,
-                RestTableInterface,
-                PrimaryKey,
-                CustomAndRequiredFields,
-                RequestTableOverrides
-            >(config, request);
+            const executor = new SqlExecutor<G>(config, request);
             return executor.execute();
         }
 
         // HTTP path fallback
         const {HttpExecutor} = await import('./executors/HttpExecutor');
-        const http = new HttpExecutor<
-            RequestMethod,
-            RestShortTableName,
-            RestTableInterface,
-            PrimaryKey,
-            CustomAndRequiredFields,
-            RequestTableOverrides
-        >(config, request);
+        const http = new HttpExecutor<G>(config, request);
         return http.execute();
     };
 }

package/src/api/types/ormGenerics.ts

@@ -0,0 +1,18 @@
+// types/ormGenerics.ts
+import { iRestMethods } from './ormInterfaces';
+
+export type OrmGenerics<
+    RequestMethod extends iRestMethods = iRestMethods,
+    RestShortTableName extends string | string[] = any,
+    RestTableInterface extends Record<string, any> = any,
+    PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string,
+    CustomAndRequiredFields extends Record<string, any> = any,
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+> = {
+    RequestMethod: RequestMethod;
+    RestShortTableName: RestShortTableName;
+    RestTableInterface: RestTableInterface;
+    PrimaryKey: PrimaryKey;
+    CustomAndRequiredFields: CustomAndRequiredFields;
+    RequestTableOverrides: RequestTableOverrides;
+};

package/src/api/types/ormInterfaces.ts

@@ -6,6 +6,7 @@ import { eFetchDependencies } from "./dynamicFetching";
 import { Modify } from "./modifyTypes";
 import { JoinType, OrderDirection, SQLComparisonOperator, SQLFunction } from "./mysqlTypes";
 import { CarbonReact } from "@carbonorm/carbonreact";
+import {OrmGenerics} from "./ormGenerics";
 
 export type iRestMethods = 'GET' | 'POST' | 'PUT' | 'DELETE';
 export const POST = 'POST';
@@ -132,8 +133,8 @@ export type DetermineResponseDataType<
 
 export interface iRest<
     RestShortTableName extends string = any,
-    RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends keyof RestTableInterface & string = any
+    RestTableInterface extends Record<string, any> = any,
+    PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string
 > {
     C6: iC6Object;
     axios?: AxiosInstance;
@@ -159,69 +160,53 @@ export type tColumns<TableName extends string, T extends { [key: string]: any }>
 
 export type tPrimaryKeys<TableName extends string, PK extends string> = `${TableName}.${PK}`;
 
-export interface iC6RestfulModel<RestShortTableNames extends string, RestTableInterfaces extends { [key: string]: any }, PK extends keyof RestTableInterfaces & string> {
-    TABLE_NAME: RestShortTableNames;
-    PRIMARY: tPrimaryKeys<RestShortTableNames, PK>[];
-    PRIMARY_SHORT: PK[];
-    COLUMNS: tColumns<RestShortTableNames, RestTableInterfaces>;
+export interface iC6RestfulModel<
+    RestShortTableName extends string,
+    RestTableInterface extends Record<string, any> = any,
+    PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string,
+> {
+    TABLE_NAME: RestShortTableName;
+    PRIMARY: tPrimaryKeys<RestShortTableName, PrimaryKey>[];
+    PRIMARY_SHORT: PrimaryKey[];
+    COLUMNS: tColumns<RestShortTableName, RestTableInterface>;
     TYPE_VALIDATION: { [key: string]: iTypeValidation };
     REGEX_VALIDATION: RegExpMap;
-    LIFECYCLE_HOOKS: iRestHooks<RestShortTableNames, RestTableInterfaces, PK>;
+    LIFECYCLE_HOOKS: iRestHooks<OrmGenerics<any, RestShortTableName, RestTableInterface, PrimaryKey>>;
     TABLE_REFERENCES: { [columnName: string]: iConstraint[] };
     TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] };
 }
 
-export type iRestReactiveLifecycle<
-    Method extends iRestMethods,
-    RestShortTableName extends string,
-    RestTableInterface extends { [key: string]: any },
-    PrimaryKey extends keyof RestTableInterface & string,
-    CustomAndRequiredFields extends { [key: string]: any },
-    RequestTableOverrides extends { [key: string]: any }
-> = {
+export type iRestReactiveLifecycle<G extends OrmGenerics> = {
     beforeProcessing?: {
         [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>;
+            request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>;
         }) => void | Promise<void>;
     };
     beforeExecution?: {
         [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>;
+            request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>;
         }) => void | Promise<void>;
     };
     afterExecution?: {
         [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
-            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+            config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>;
+            request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>;
+            response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
         }) => void | Promise<void>;
     };
     afterCommit?: {
         [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
-            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+            config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>;
+            request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>;
+            response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
         }) => void | Promise<void>;
     };
 };
 
-export type iRestHooks<
-    RestShortTableName extends string,
-    RestTableInterface extends { [key: string]: any },
-    PrimaryKey extends keyof RestTableInterface & string,
-    CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key: string]: any } = { [key in keyof RestTableInterface]: any }
-> = {
-    [Method in iRestMethods]: iRestReactiveLifecycle<
-        Method,
-        RestShortTableName,
-        RestTableInterface,
-        PrimaryKey,
-        CustomAndRequiredFields,
-        RequestTableOverrides
-    >;
+export type iRestHooks<G extends OrmGenerics> = {
+    [Method in iRestMethods]: iRestReactiveLifecycle<G>;
 };
 
 export interface iDynamicApiImport<RestData extends { [key: string]: any } = any> {
@@ -241,7 +226,7 @@ export interface iRestApiFunctions<RestData extends { [key: string]: any } = any
 export interface iC6Object<
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
+    PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string
 > {
     C6VERSION: string;
     TABLES: {
@@ -257,7 +242,7 @@ export interface iC6Object<
 export interface tC6Tables<
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = any,
-    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
+    PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string
 > {
     [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & { [key: string]: any };
 }

package/src/index.ts

@@ -12,14 +12,23 @@ export { default as restRequest } from "./api/restRequest";
 export * from "./api/restRequest";
 export { default as timeout } from "./api/timeout";
 export * from "./api/timeout";
-export * from "./api/builders/sqlBuilder";
 export * from "./api/executors/Executor";
 export * from "./api/executors/HttpExecutor";
 export * from "./api/executors/SqlExecutor";
 export * from "./api/handlers/ExpressHandler";
+export * from "./api/orm/queryHelpers";
+export * from "./api/orm/builders/AggregateBuilder";
+export * from "./api/orm/builders/ConditionBuilder";
+export * from "./api/orm/builders/JoinBuilder";
+export * from "./api/orm/builders/PaginationBuilder";
+export * from "./api/orm/queries/DeleteQueryBuilder";
+export * from "./api/orm/queries/SelectQueryBuilder";
+export * from "./api/orm/queries/UpdateQueryBuilder";
+export * from "./api/orm/utils/sqlUtils";
 export * from "./api/types/dynamicFetching";
 export * from "./api/types/modifyTypes";
 export * from "./api/types/mysqlTypes";
+export * from "./api/types/ormGenerics";
 export * from "./api/types/ormInterfaces";
 export * from "./api/utils/apiHelpers";
 export * from "./api/utils/cacheManager";