@carbonorm/carbonnode 3.0.13 → 3.1.2

package/dist/api/C6Constants.d.ts

@@ -60,6 +60,7 @@ export declare const C6Constants: {
     LOCALTIMESTAMP: string;
     MAKEDATE: string;
     MAKETIME: string;
+    MATCH_AGAINST: string;
     MONTHNAME: string;
     MICROSECOND: string;
     MINUTE: string;
@@ -80,6 +81,189 @@ export declare const C6Constants: {
     SECOND: string;
     SECOND_MICROSECOND: string;
     SELECT: string;
+    ST_AREA: string;
+    ST_ASBINARY: string;
+    ST_ASTEXT: string;
+    ST_BUFFER: string;
+    ST_CONTAINS: string;
+    ST_CROSSES: string;
+    ST_DIFFERENCE: string;
+    ST_DIMENSION: string;
+    ST_DISJOINT: string;
+    ST_DISTANCE: string;
+    ST_DISTANCE_SPHERE: string;
+    ST_ENDPOINT: string;
+    ST_ENVELOPE: string;
+    ST_EQUALS: string;
+    ST_GEOMFROMGEOJSON: string;
+    ST_GEOMFROMTEXT: string;
+    ST_GEOMFROMWKB: string;
+    ST_INTERSECTS: string;
+    ST_LENGTH: string;
+    ST_OVERLAPS: string;
+    ST_POINT: string;
+    ST_SETSRID: string;
+    ST_SRID: string;
+    ST_STARTPOINT: string;
+    ST_SYMDIFFERENCE: string;
+    ST_TOUCHES: string;
+    ST_UNION: string;
+    ST_WITHIN: string;
+    ST_X: string;
+    ST_Y: string;
+    STR_TO_DATE: string;
+    SUBDATE: string;
+    SUBTIME: string;
+    SUM: string;
+    SYSDATE: string;
+    TIME: string;
+    TIME_FORMAT: string;
+    TIME_TO_SEC: string;
+    TIMEDIFF: string;
+    TIMESTAMP: string;
+    TIMESTAMPADD: string;
+    TIMESTAMPDIFF: string;
+    TO_DAYS: string;
+    TO_SECONDS: string;
+    TRANSACTION_TIMESTAMP: string;
+    TRUE: string;
+    UNIX_TIMESTAMP: string;
+    UNKNOWN: string;
+    UPDATE: string;
+    UNHEX: string;
+    UTC_DATE: string;
+    UTC_TIME: string;
+    UTC_TIMESTAMP: string;
+    WHERE: string;
+    WEEKDAY: string;
+    WEEKOFYEAR: string;
+    YEARWEEK: string;
+    DEPENDANT_ON_ENTITY: string;
+    OPTIONS: string;
+    GET: string;
+    POST: string;
+    PUT: string;
+    REPLACE: string;
+    DELETE: string;
+    REST_REQUEST_PREPROCESS_CALLBACKS: string;
+    PREPROCESS: string;
+    REST_REQUEST_FINNISH_CALLBACKS: string;
+    FINISH: string;
+    VALIDATE_C6_ENTITY_ID_REGEX: string;
+};
+export declare const C6C: {
+    ADDDATE: string;
+    ADDTIME: string;
+    AS: string;
+    ASC: string;
+    BETWEEN: string;
+    CONCAT: string;
+    CONVERT_TZ: string;
+    COUNT: string;
+    COUNT_ALL: string;
+    CURRENT_DATE: string;
+    CURRENT_TIMESTAMP: string;
+    DAY: string;
+    DAY_HOUR: string;
+    DAY_MICROSECOND: string;
+    DAY_MINUTE: string;
+    DAY_SECOND: string;
+    DAYNAME: string;
+    DAYOFMONTH: string;
+    DAYOFWEEK: string;
+    DAYOFYEAR: string;
+    DATE: string;
+    DATE_ADD: string;
+    DATEDIFF: string;
+    DATE_SUB: string;
+    DATE_FORMAT: string;
+    DESC: string;
+    DISTINCT: string;
+    EXTRACT: string;
+    EQUAL: string;
+    EQUAL_NULL_SAFE: string;
+    FALSE: string;
+    FULL_OUTER: string;
+    FROM_DAYS: string;
+    FROM_UNIXTIME: string;
+    GET_FORMAT: string;
+    GREATER_THAN: string;
+    GROUP_BY: string;
+    GROUP_CONCAT: string;
+    GREATER_THAN_OR_EQUAL_TO: string;
+    HAVING: string;
+    HEX: string;
+    HOUR: string;
+    HOUR_MICROSECOND: string;
+    HOUR_SECOND: string;
+    HOUR_MINUTE: string;
+    IN: string;
+    IS: string;
+    IS_NOT: string;
+    INNER: string;
+    INTERVAL: string;
+    JOIN: string;
+    LEFT: string;
+    LEFT_OUTER: string;
+    LESS_THAN: string;
+    LESS_THAN_OR_EQUAL_TO: string;
+    LIKE: string;
+    LIMIT: string;
+    LOCALTIME: string;
+    LOCALTIMESTAMP: string;
+    MAKEDATE: string;
+    MAKETIME: string;
+    MATCH_AGAINST: string;
+    MONTHNAME: string;
+    MICROSECOND: string;
+    MINUTE: string;
+    MINUTE_MICROSECOND: string;
+    MINUTE_SECOND: string;
+    MIN: string;
+    MAX: string;
+    MONTH: string;
+    NOT_LIKE: string;
+    NOT_EQUAL: string;
+    NOT_IN: string;
+    NOW: string;
+    NULL: string;
+    ORDER: string;
+    PAGE: string;
+    PAGINATION: string;
+    RIGHT_OUTER: string;
+    SECOND: string;
+    SECOND_MICROSECOND: string;
+    SELECT: string;
+    ST_AREA: string;
+    ST_ASBINARY: string;
+    ST_ASTEXT: string;
+    ST_BUFFER: string;
+    ST_CONTAINS: string;
+    ST_CROSSES: string;
+    ST_DIFFERENCE: string;
+    ST_DIMENSION: string;
+    ST_DISJOINT: string;
+    ST_DISTANCE: string;
+    ST_DISTANCE_SPHERE: string;
+    ST_ENDPOINT: string;
+    ST_ENVELOPE: string;
+    ST_EQUALS: string;
+    ST_GEOMFROMGEOJSON: string;
+    ST_GEOMFROMTEXT: string;
+    ST_GEOMFROMWKB: string;
+    ST_INTERSECTS: string;
+    ST_LENGTH: string;
+    ST_OVERLAPS: string;
+    ST_POINT: string;
+    ST_SETSRID: string;
+    ST_SRID: string;
+    ST_STARTPOINT: string;
+    ST_SYMDIFFERENCE: string;
+    ST_TOUCHES: string;
+    ST_UNION: string;
+    ST_WITHIN: string;
+    ST_X: string;
+    ST_Y: string;
     STR_TO_DATE: string;
     SUBDATE: string;
     SUBTIME: string;

package/dist/api/builders/queryHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare const A: (tableName: string, alias: string) => string;
+export declare const F: (qualifiedCol: string, alias: string) => string;
+export declare const fieldEq: (leftCol: string, rightCol: string, leftAlias: string, rightAlias: string) => Record<string, string>;
+export declare const distSphere: (fromCol: string, toCol: string, fromAlias: string, toAlias: string) => any[];

package/dist/api/builders/sqlBuilder.d.ts

@@ -2,7 +2,9 @@ import { Executor } from "../executors/Executor";
 import { iRestMethods } from "../types/ormInterfaces";
 interface QueryResult {
     sql: string;
-    params: any[];
+    params: any[] | {
+        [key: string]: any;
+    };
 }
 export declare abstract class SqlBuilder<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 {
     [key: string]: any;
@@ -11,11 +13,21 @@ export declare abstract class SqlBuilder<RequestMethod extends iRestMethods, Res
 } = {
     [key in keyof RestTableInterface]: any;
 }> extends Executor<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides> {
-    /** Generate nested WHERE/JOIN conditions with parameter binding */
-    protected buildBooleanJoinedConditions(set: any, andMode?: boolean, params?: any[]): string;
-    /** Translate array or function calls into SQL expressions */
+    /** Flag to determine if named placeholders should be used */
+    protected useNamedParams: boolean;
+    private convertHexIfBinary;
+    /** Generate nested WHERE/ON conditions with parameter binding (supports AND/OR/NOT) */
+    protected buildBooleanJoinedConditions(set: any, andMode?: boolean, params?: any[] | {
+        [key: string]: any;
+    }): string;
+    /** Translate array or function call definitions into SQL expressions (supports nested calls) */
     protected buildAggregateField(field: string | any[]): string;
-    /** Compose a parameterized SELECT query with optional JOIN/WHERE/GROUP/HAVING/PAGINATION */
+    private buildJoinClauses;
+    private buildPaginationClause;
+    private buildWhereClause;
     protected buildSelectQuery<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any, isSubSelect?: boolean): QueryResult;
+    protected buildUpdateQuery(table: RestShortTableName, data: Partial<RestTableInterface>, args?: any): QueryResult;
+    /** Compose a DELETE query with optional JOIN and WHERE clauses */
+    protected buildDeleteQuery(table: RestShortTableName, args?: any): QueryResult;
 }
 export {};

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

@@ -1,16 +1,10 @@
-import { apiReturn, DetermineResponseDataType, iRest, iRestMethods, iRestReactiveLifecycle, RequestQueryBody } from "../types/ormInterfaces";
-export declare abstract class Executor<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;
-}> {
-    protected config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-    protected request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
-    constructor(config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>);
-    abstract execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
-    runLifecycleHooks<Phase extends keyof iRestReactiveLifecycle<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>>(phase: Phase, args: Parameters<NonNullable<iRestReactiveLifecycle<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>[Phase]>[string]>[0]): Promise<void>;
+import { OrmGenerics } from "../types/ormGenerics";
+import { apiReturn, DetermineResponseDataType, iRest, iRestReactiveLifecycle, RequestQueryBody } from "../types/ormInterfaces";
+export declare abstract class Executor<G extends OrmGenerics> {
+    protected config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>;
+    protected request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>;
+    protected useNamedParams: boolean;
+    constructor(config: iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>, request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>, useNamedParams?: boolean);
+    abstract execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>>;
+    runLifecycleHooks<Phase extends keyof iRestReactiveLifecycle<G>>(phase: Phase, args: Parameters<NonNullable<iRestReactiveLifecycle<G>[Phase]>[string]>[0]): Promise<void>;
 }

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

@@ -1,17 +1,10 @@
 import { AxiosResponse } from "axios";
-import { apiReturn, DetermineResponseDataType, iRestMethods, RequestQueryBody } from "../types/ormInterfaces";
+import { OrmGenerics } from "../types/ormGenerics";
+import { apiReturn, DetermineResponseDataType, RequestQueryBody } from "../types/ormInterfaces";
 import { Executor } from "./Executor";
-export declare 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;
-}> extends Executor<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides> {
-    putState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
-    postState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
-    deleteState(_response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
-    execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
+export declare class HttpExecutor<G extends OrmGenerics> extends Executor<G> {
+    putState(response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>, request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>, callback: () => void): void;
+    postState(response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>, request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>, callback: () => void): void;
+    deleteState(_response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>, request: RequestQueryBody<G['RequestMethod'], G['RestTableInterface'], G['CustomAndRequiredFields'], G['RequestTableOverrides']>, callback: () => void): void;
+    execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>>;
 }

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

@@ -1,16 +1,45 @@
-import { SqlBuilder } from "api/builders/sqlBuilder";
-import { apiReturn, DetermineResponseDataType, iRestMethods } from "../types/ormInterfaces";
-import { RowDataPacket, ResultSetHeader } from 'mysql2/promise';
-export declare 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> {
-    execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
+import { OrmGenerics } from "../types/ormGenerics";
+import { apiReturn, 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<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>>;
     private withConnection;
-    select<TName extends string>(table: TName, primary: string | undefined, args: any): Promise<RowDataPacket[]>;
-    insert<TName extends string>(table: TName, data: Record<string, any>): Promise<ResultSetHeader>;
-    update<TName extends string>(table: TName, primary: string[], data: Record<string, any>): Promise<ResultSetHeader>;
-    delete<TName extends string>(table: TName, primary: string[], args: Record<string, any>): Promise<ResultSetHeader>;
-    formatSQLWithParams(sql: string, params: any[]): string;
+    serialize: (row: any) => {
+        [k: string]: unknown;
+    };
+    select(table: G['RestShortTableName'], primary: string | undefined, args: any): Promise<{
+        rest: {
+            [k: string]: unknown;
+        }[];
+        sql: {
+            sql: any;
+            values: any;
+        };
+    }>;
+    insert(table: G['RestShortTableName'], data: Record<string, any>): Promise<{
+        rest: ResultSetHeader;
+        sql: {
+            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>;
+        };
+    }>;
+    formatSQLWithParams(sql: string, params: any[] | {
+        [key: string]: any;
+    }): string;
+    private formatValue;
 }

package/dist/api/orm/SqlBuilder.d.ts

@@ -0,0 +1,17 @@
+import { Executor } from '../executors/Executor';
+import { OrmGenerics } from "../types/ormGenerics";
+import { SelectQueryBuilder } from './queries/SelectQueryBuilder';
+import { UpdateQueryBuilder } from './queries/UpdateQueryBuilder';
+import { DeleteQueryBuilder } from './queries/DeleteQueryBuilder';
+import { SqlBuilderResult } from "./utils/sqlUtils";
+export declare abstract class SqlBuilder<G extends OrmGenerics> extends Executor<G> {
+    protected useNamedParams: boolean;
+    private aggregateBuilder;
+    private conditionBuilder;
+    private joinBuilder;
+    private paginationBuilder;
+    protected selectQueryBuilder: SelectQueryBuilder<OrmGenerics>;
+    protected updateQueryBuilder: UpdateQueryBuilder<OrmGenerics>;
+    protected deleteQueryBuilder: DeleteQueryBuilder<OrmGenerics>;
+    protected buildSelectQuery(table: RestShortTableName, primary: string | undefined, args: any, isSubSelect?: boolean): SqlBuilderResult;
+}

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

@@ -0,0 +1,5 @@
+import { Executor } from "../../executors/Executor";
+import { OrmGenerics } from "../../types/ormGenerics";
+export declare abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G> {
+    buildAggregateField(field: string | any[]): string;
+}

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

@@ -0,0 +1,11 @@
+import { OrmGenerics } from "../../types/ormGenerics";
+import { apiReturn, DetermineResponseDataType } from "../../types/ormInterfaces";
+import { AggregateBuilder } from "./AggregateBuilder";
+export declare class ConditionBuilder<G extends OrmGenerics> extends AggregateBuilder<G> {
+    execute(): Promise<apiReturn<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>>;
+    private readonly OPERATORS;
+    private validateOperator;
+    private addParam;
+    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

@@ -0,0 +1,5 @@
+import { OrmGenerics } from "../../types/ormGenerics";
+import { ConditionBuilder } from "./ConditionBuilder";
+export declare 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

@@ -0,0 +1,5 @@
+import { OrmGenerics } from "../../types/ormGenerics";
+import { JoinBuilder } from "./JoinBuilder";
+export declare class PaginationBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
+    buildPaginationClause(pagination: any): string;
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,6 @@
+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;
+}

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

@@ -0,0 +1,6 @@
+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;
+}

package/dist/api/orm/queryHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare const A: (tableName: string, alias: string) => string;
+export declare const F: (qualifiedCol: string, alias: string) => string;
+export declare const fieldEq: (leftCol: string, rightCol: string, leftAlias: string, rightAlias: string) => Record<string, string>;
+export declare const distSphere: (fromCol: string, toCol: string, fromAlias: string, toAlias: string) => any[];

package/dist/api/orm/utils/sqlUtils.d.ts

@@ -0,0 +1,7 @@
+export interface SqlBuilderResult {
+    sql: string;
+    params: any[] | {
+        [key: string]: any;
+    };
+}
+export declare function convertHexIfBinary(_col: string, val: any, columnDef?: any): any;

package/dist/api/restOrm.d.ts

@@ -1,12 +1,5 @@
+import { OrmGenerics } from "./types/ormGenerics";
 import { iRest } from "./types/ormInterfaces";
-export declare 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">): {
-    [k: string]: (request: import("./types/ormInterfaces").iAPI<import("./types/ormInterfaces").RequestGetPutDeleteBody<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>> | import("./types/ormInterfaces").iAPI<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<RestTableInterface, {}> | import("./types/ormInterfaces").iPostC6RestResponse<RestTableInterface> | import("./types/ormInterfaces").iPutC6RestResponse<RestTableInterface, any> | import("./types/ormInterfaces").iDeleteC6RestResponse<RestTableInterface, any>>>;
+export declare function restOrm<G extends Omit<OrmGenerics, "requestMethod">>(config: () => Omit<iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>, "requestMethod">): {
+    [k: string]: (request: import("./types/ormInterfaces").RequestQueryBody<G["RequestMethod"], G["RestTableInterface"], G["CustomAndRequiredFields"], G["RequestTableOverrides"]>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").DetermineResponseDataType<G["RequestMethod"], G["RestTableInterface"]>>>;
 };

package/dist/api/restRequest.d.ts

@@ -1,13 +1,6 @@
-import { apiReturn, DetermineResponseDataType, iRest, iRestMethods, RequestQueryBody } from "./types/ormInterfaces";
+import { OrmGenerics } from "./types/ormGenerics";
+import { apiReturn, DetermineResponseDataType, 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;
-}>(configX: (() => iRest<RestShortTableName, RestTableInterface, PrimaryKey>) | iRest<RestShortTableName, RestTableInterface, PrimaryKey>): (request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>) => Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
+export default function restRequest<G extends OrmGenerics>(configX: (() => iRest<G['RestTableInterface'], G['RestShortTableName'], G['PrimaryKey']>) | iRest<G['RestShortTableName'], G['RestTableInterface'], G['PrimaryKey']>): (request: RequestQueryBody<G["RequestMethod"], G["RestTableInterface"], G["CustomAndRequiredFields"], G["RequestTableOverrides"]>) => Promise<apiReturn<DetermineResponseDataType<G["RequestMethod"], G["RestTableInterface"]>>>;

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

@@ -0,0 +1,13 @@
+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/dist/api/types/ormInterfaces.d.ts

@@ -4,6 +4,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 declare const POST = "POST";
 export declare const PUT = "PUT";
@@ -110,9 +111,7 @@ export type apiReturn<Response> = null | undefined | Response | (Response extend
 export type DetermineResponseDataType<Method extends iRestMethods, RestTableInterface extends {
     [key: string]: any;
 }> = Method extends 'POST' ? iPostC6RestResponse<RestTableInterface> : Method extends 'GET' ? iGetC6RestResponse<RestTableInterface> : Method extends 'PUT' ? iPutC6RestResponse<RestTableInterface> : Method extends 'DELETE' ? iDeleteC6RestResponse<RestTableInterface> : never;
-export interface iRest<RestShortTableName extends string = any, RestTableInterface extends {
-    [key: string]: any;
-} = any, PrimaryKey extends keyof RestTableInterface & string = any> {
+export interface iRest<RestShortTableName extends string = any, RestTableInterface extends Record<string, any> = any, PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string> {
     C6: iC6Object;
     axios?: AxiosInstance;
     restURL?: string;
@@ -135,18 +134,16 @@ export type tColumns<TableName extends string, T extends {
     [K in keyof T & string as `${TableName}.${K}`]: K;
 };
 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[];
     };
@@ -154,50 +151,36 @@ export interface iC6RestfulModel<RestShortTableNames extends string, RestTableIn
         [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;
@@ -217,7 +200,7 @@ export interface iRestApiFunctions<RestData extends {
 }
 export interface iC6Object<RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
-} = any, PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>> {
+} = any, PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string> {
     C6VERSION: string;
     TABLES: {
         [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & {
@@ -230,7 +213,7 @@ export interface iC6Object<RestShortTableName extends string = any, RestTableInt
 }
 export interface tC6Tables<RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
-} = any, PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>> {
+} = any, PrimaryKey extends keyof RestTableInterface & string = keyof RestTableInterface & string> {
     [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & {
         [key: string]: any;
     };