@carbonorm/carbonnode 3.7.6 → 3.7.7

package/src/__tests__/sakila.generated.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+
+// Import the generated C6.js from sakila-db folder (ESM)
+// This file is generated from the Sakila schema and wired with restOrm
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - C6.js is JS, vitest/ts handles ESM imports fine
+import { C6, GLOBAL_REST_PARAMETERS } from './sakila-db/C6.js';
+
+function toPascalCase(name: string) {
+  return name.replace(/(^|_)([a-z])/g, (_m, _u, c) => c.toUpperCase());
+}
+
+describe('sakila-db generated C6 bindings', () => {
+  beforeAll(() => {
+    // Provide a mocked MySQL pool so SqlExecutor path is used without a real DB
+    const mockConn = {
+      query: vi.fn().mockImplementation(async (_sql: string, _values?: any[]) => {
+        // Return a result set shaped like mysql2/promise: [rows, fields]
+        return [[{ ok: true }], []];
+      }),
+      release: vi.fn()
+    };
+
+    const mockPool = {
+      getConnection: vi.fn().mockResolvedValue(mockConn)
+    } as any;
+
+    // Inject mocked pool into global rest parameters used by all table bindings
+    GLOBAL_REST_PARAMETERS.mysqlPool = mockPool;
+  });
+
+  it('Get(...LIMIT...) returns array rest for every generated table', async () => {
+    // Iterate over each table short name present in generated C6
+    for (const [shortName] of Object.entries(C6.TABLES as Record<string, any>)) {
+      const bindingName = toPascalCase(shortName);
+      const restBinding = (C6.ORM as Record<string, any>)[bindingName];
+      if (!restBinding || typeof restBinding.Get !== 'function') continue;
+
+      const response = await restBinding.Get({ SELECT: ['*'], [C6.PAGINATION]: { [C6.LIMIT]: 1 } } as any);
+
+      // HttpExecutor returns AxiosResponse, SqlExecutor returns plain object
+      const data = (response as any)?.data ?? response;
+      expect(Array.isArray((data as any)?.rest)).toBe(true);
+    }
+  });
+});

package/src/__tests__/sqlBuilders.complex.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { C6C } from '../api/C6Constants';
+import { SelectQueryBuilder } from '../api/orm/queries/SelectQueryBuilder';
+import { buildTestConfig } from './fixtures/c6.fixture';
+
+/**
+ * Complex SELECT coverage focused on WHERE operators, JOIN chains, ORDER, and pagination.
+ */
+describe('SQL Builders - Complex SELECTs', () => {
+  it('supports nested AND/OR groups, IN/NOT IN, BETWEEN, IS NULL', () => {
+    const config = buildTestConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.actor_id', 'actor.first_name'],
+      WHERE: {
+        // AND root with one direct condition
+        'actor.first_name': [C6C.LIKE, 'A%'],
+        // OR group #1
+        0: {
+          'actor.actor_id': [C6C.IN, [1, 2, 3]]
+        },
+        // OR group #2
+        1: {
+          'actor.actor_id': [C6C.BETWEEN, [5, 10]]
+        },
+        // OR group #3
+        2: {
+          'actor.last_name': [C6C.IS, null]
+        },
+        // AND with NOT IN
+        'actor.last_name': [C6C.NOT_IN, ['SMITH', 'DOE']]
+      }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    // SQL fragments
+    expect(sql).toContain('SELECT actor.actor_id, actor.first_name FROM `actor`');
+    expect(sql).toContain('WHERE');
+    expect(sql).toMatch(/\(actor\.first_name\) LIKE \?/);
+    expect(sql).toMatch(/\( actor\.actor_id IN \((\?,\s*){2}\?\) \)/); // 3 placeholders
+    expect(sql).toMatch(/\(actor\.actor_id\) BETWEEN \? AND \?/);
+    expect(sql).toMatch(/\(actor\.last_name\) IS \?/);
+    expect(sql).toMatch(/\( actor\.last_name NOT IN \((\?,\s*)\?\) \)/);
+    // default LIMIT
+    expect(sql.trim().endsWith('LIMIT 100')).toBe(true);
+
+    // Params order: non-numeric entries first, then grouped (implementation detail)
+    // We asserted shape above; ensure counts match
+    expect(params).toHaveLength(1 + 3 + 2 + 1 + 2); // LIKE + IN(3) + BETWEEN(2) + IS(1 param) + NOT IN(2)
+    expect(params[0]).toBe('A%');
+  });
+
+  it('builds chained mixed JOINs with aliases', () => {
+    const config = buildTestConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.actor_id'],
+      JOIN: {
+        [C6C.INNER]: {
+          'film_actor fa': { 'fa.actor_id': [C6C.EQUAL, 'actor.actor_id'] }
+        },
+        [C6C.LEFT]: {
+          'film_actor fb': { 'fb.actor_id': [C6C.EQUAL, 'actor.actor_id'] }
+        }
+      },
+      WHERE: { 'actor.actor_id': [C6C.GREATER_THAN, 0] }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('FROM `actor`');
+    expect(sql).toContain('INNER JOIN `film_actor` AS `fa` ON');
+    expect(sql).toContain('LEFT JOIN `film_actor` AS `fb` ON');
+    expect(sql).toMatch(/\(actor\.actor_id\) > \?/);
+    expect(params).toEqual([0]);
+  });
+
+  it('orders by multiple fields and honors PAGE/LIMIT offset', () => {
+    const config = buildTestConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.actor_id', 'actor.first_name'],
+      WHERE: { 'actor.actor_id': [C6C.GREATER_THAN, 10] },
+      PAGINATION: {
+        [C6C.ORDER]: {
+          'actor.last_name': 'ASC',
+          'actor.first_name': 'DESC'
+        },
+        [C6C.LIMIT]: 10,
+        [C6C.PAGE]: 3
+      }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('ORDER BY actor.last_name ASC, actor.first_name DESC');
+    expect(sql.trim().endsWith('LIMIT 20, 10')).toBe(true); // (page-1)*limit, limit
+    expect(params).toEqual([10]);
+  });
+
+  it('supports DISTINCT and HAVING on aggregated alias', () => {
+    const config = buildTestConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: [[C6C.DISTINCT, 'actor.first_name'], [C6C.COUNT, 'actor.actor_id', C6C.AS, 'cnt']],
+      GROUP_BY: 'actor.first_name',
+      HAVING: { 'cnt': [C6C.GREATER_THAN, 1] }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('SELECT DISTINCT actor.first_name, COUNT(actor.actor_id) AS cnt FROM `actor`');
+    expect(sql).toContain('GROUP BY actor.first_name');
+    expect(sql).toContain('HAVING');
+    expect(params).toEqual([1]);
+  });
+
+  it('supports MATCH_AGAINST fulltext condition variants', () => {
+    const config = buildTestConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.actor_id'],
+      WHERE: {
+        'actor.first_name': [C6C.MATCH_AGAINST, ['alpha beta', 'BOOLEAN']]
+      }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toMatch(/MATCH\(actor\.first_name\) AGAINST\(\? IN BOOLEAN MODE\)/);
+    expect(params).toEqual(['alpha beta']);
+  });
+});

package/src/__tests__/sqlBuilders.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { C6C } from '../api/C6Constants';
+import { SelectQueryBuilder } from '../api/orm/queries/SelectQueryBuilder';
+import { PostQueryBuilder } from '../api/orm/queries/PostQueryBuilder';
+import { UpdateQueryBuilder } from '../api/orm/queries/UpdateQueryBuilder';
+import { DeleteQueryBuilder } from '../api/orm/queries/DeleteQueryBuilder';
+import { buildTestConfig } from './fixtures/c6.fixture';
+
+describe('SQL Builders', () => {
+  it('builds SELECT with JOIN, WHERE, GROUP BY, HAVING and default LIMIT', () => {
+    const config = buildTestConfig();
+    // named params disabled -> positional params array
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.first_name', [C6C.COUNT, 'actor.actor_id', C6C.AS, 'cnt']],
+      JOIN: {
+        [C6C.INNER]: {
+          'film_actor fa': {
+            'fa.actor_id': [C6C.EQUAL, 'actor.actor_id']
+          }
+        }
+      },
+      WHERE: {
+        'actor.first_name': [C6C.LIKE, '%A%'],
+        0: {
+          'actor.actor_id': [C6C.GREATER_THAN, 10],
+        }
+      },
+      GROUP_BY: 'actor.first_name',
+      HAVING: {
+        'cnt': [C6C.GREATER_THAN, 1]
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('SELECT actor.first_name, COUNT(actor.actor_id) AS cnt FROM `actor`');
+    expect(sql).toContain('INNER JOIN `film_actor` AS `fa` ON');
+    expect(sql).toContain('(actor.first_name) LIKE ?');
+    expect(sql).toContain('(actor.actor_id) > ?');
+    expect(sql).toContain('GROUP BY actor.first_name');
+    expect(sql).toContain('HAVING');
+    expect(sql.trim().endsWith('LIMIT 100')).toBe(true);
+    expect(params).toEqual(['%A%', 10, 1]);
+  });
+
+  it('builds INSERT with ON DUPLICATE KEY UPDATE', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.REPLACE]: {
+        'actor.first_name': 'BOB',
+        'actor.last_name': 'SMITH',
+      },
+      [C6C.UPDATE]: ['first_name', 'last_name'],
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('REPLACE INTO `actor`');
+    expect(sql).toContain('`first_name`, `last_name`');
+    expect(sql).toContain('ON DUPLICATE KEY UPDATE `first_name` = VALUES(`first_name`), `last_name` = VALUES(`last_name`)');
+    expect(params).toEqual(['BOB', 'SMITH']);
+  });
+
+  it('builds UPDATE with WHERE and pagination', () => {
+    const config = buildTestConfig();
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'first_name': 'ALICE',
+      },
+      WHERE: {
+        'actor.actor_id': [C6C.EQUAL, 5],
+      },
+      PAGINATION: { LIMIT: 1 }
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql.startsWith('UPDATE `actor` SET')).toBe(true);
+    expect(sql).toContain('`first_name` = ?');
+    expect(sql).toContain('WHERE (actor.actor_id) = ?');
+    expect(sql).toContain('LIMIT 1');
+    expect(params).toEqual(['ALICE', 5]);
+  });
+
+  it('builds DELETE with JOIN and WHERE', () => {
+    const config = buildTestConfig();
+    const qb = new DeleteQueryBuilder(config as any, {
+      JOIN: {
+        [C6C.INNER]: {
+          'film_actor fa': {
+            'fa.actor_id': [C6C.EQUAL, 'actor.actor_id']
+          }
+        }
+      },
+      WHERE: { 'actor.actor_id': [C6C.GREATER_THAN, 100] },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('DELETE `actor` FROM `actor`');
+    expect(sql).toContain('INNER JOIN `film_actor` AS `fa` ON');
+    expect(sql).toContain('(actor.actor_id) > ?');
+    expect(params).toEqual([100]);
+  });
+
+  it('converts hex to Buffer for BINARY columns in WHERE params', () => {
+    const config = buildTestConfig();
+    const qb = new SelectQueryBuilder(config as any, {
+      WHERE: {
+        'actor.binarycol': [C6C.EQUAL, '0123456789abcdef0123456789abcdef']
+      }
+    } as any, false);
+
+    const { params } = qb.build('actor');
+    expect(Array.isArray(params)).toBe(true);
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+});
+

package/src/api/convertForRequestBody.ts

@@ -1,4 +1,4 @@
-import { C6Constants } from "api/C6Constants";
+import { C6Constants } from "./C6Constants";
 import {iC6Object, C6RestfulModel, iRestMethods, RequestQueryBody} from "./types/ormInterfaces";
 
 export default function <

package/src/api/executors/HttpExecutor.ts

@@ -15,6 +15,7 @@ import {
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
+import { normalizeSingularRequest } from "../utils/normalizeSingularRequest";
 import {apiRequestCache, checkCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {Executor} from "./Executor";
@@ -336,6 +337,7 @@ export class HttpExecutor<
             }
 
             let addBackPK: (() => void) | undefined;
+            let removedPrimaryKV: { key: string; value: any } | undefined;
 
             let apiResponse: G['RestTableInterface'][G['PrimaryKey']] | string | boolean | number | undefined;
 
@@ -411,6 +413,7 @@ export class HttpExecutor<
                 restRequestUri += query[primaryKey] + '/'
 
                 const removedPkValue = query[primaryKey];
+                removedPrimaryKV = { key: primaryKey, value: removedPkValue };
 
                 addBackPK = () => {
                     query ??= {} as RequestQueryBody<
@@ -472,11 +475,19 @@ export class HttpExecutor<
                             withCredentials: withCredentials,
                         };
 
+                        // Normalize singular request (GET/PUT/DELETE) into complex ORM shape
+                        const normalizedQuery = normalizeSingularRequest(
+                            requestMethod as any,
+                            query as any,
+                            restModel as any,
+                            removedPrimaryKV
+                        ) as typeof query;
+
                         switch (requestMethod) {
                             case GET:
                                 return [{
                                     ...baseConfig,
-                                    params: query
+                                    params: normalizedQuery
                                 }];
 
                             case POST:
@@ -489,12 +500,12 @@ export class HttpExecutor<
                                 return [convert(query), baseConfig];
 
                             case PUT:
-                                return [convert(query), baseConfig];
+                                return [convert(normalizedQuery), baseConfig];
 
                             case DELETE:
                                 return [{
                                     ...baseConfig,
-                                    data: convert(query)
+                                    data: convert(normalizedQuery)
                                 }];
 
                             default:

package/src/api/executors/SqlExecutor.ts

@@ -10,6 +10,7 @@ import namedPlaceholders from 'named-placeholders';
 import {PoolConnection} from 'mysql2/promise';
 import {Buffer} from 'buffer';
 import {Executor} from "./Executor";
+import { normalizeSingularRequest } from "../utils/normalizeSingularRequest";
 
 export class SqlExecutor<
     G extends OrmGenerics
@@ -19,10 +20,22 @@ export class SqlExecutor<
         const {TABLE_NAME} = this.config.restModel;
         const method = this.config.requestMethod;
 
+        // Normalize singular T-shaped requests into complex ORM shape (GET/PUT/DELETE)
+        try {
+            this.request = normalizeSingularRequest(
+                method as any,
+                this.request as any,
+                this.config.restModel as any,
+                undefined
+            ) as typeof this.request;
+        } catch (e) {
+            // Surface normalization errors early
+            throw e;
+        }
+
         this.config.verbose && console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
         this.config.verbose && console.log(`[SQL EXECUTOR] 🧩 Request:`, this.request);
 
-
         switch (method) {
             case 'GET': {
                 const rest = await this.runQuery();

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

@@ -2,6 +2,8 @@ import {Executor} from "../../executors/Executor";
 import {OrmGenerics} from "../../types/ormGenerics";
 
 export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G>{
+    protected selectAliases: Set<string> = new Set<string>();
+
     buildAggregateField(field: string | any[]): string {
         if (typeof field === 'string') {
             return field;
@@ -33,6 +35,7 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
         }
 
         if (alias) {
+            this.selectAliases.add(alias);
             expr += ` AS ${alias}`;
         }
 

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

@@ -1,4 +1,4 @@
-import {C6C} from "api/C6Constants";
+import {C6C} from "../../C6Constants";
 import {OrmGenerics} from "../../types/ormGenerics";
 import {DetermineResponseDataType} from "../../types/ormInterfaces";
 import {convertHexIfBinary, SqlBuilderResult} from "../utils/sqlUtils";
@@ -65,7 +65,16 @@ export abstract class ConditionBuilder<
     ]);
 
     private isTableReference(val: any): boolean {
-        if (typeof val !== 'string' || !val.includes('.')) return false;
+        if (typeof val !== 'string') return false;
+        // Support aggregate aliases (e.g., SELECT COUNT(x) AS cnt ... HAVING cnt > 1)
+        if (!val.includes('.')) {
+            const isIdentifier = /^[A-Za-z_][A-Za-z0-9_]*$/.test(val);
+            // selectAliases is defined in AggregateBuilder
+            if (isIdentifier && (this as any).selectAliases?.has(val)) {
+                return true;
+            }
+            return false;
+        }
         const [prefix, column] = val.split('.');
         const tableName = this.aliasMap[prefix] ?? prefix;
         const table = this.config.C6?.TABLES?.[tableName];
@@ -90,7 +99,13 @@ export abstract class ConditionBuilder<
         column: string,
         value: any
     ): string {
-        const columnDef = this.config.C6[column.split('.')[0]]?.TYPE_VALIDATION?.[column];
+        // Determine column definition from C6.TABLES to support type-aware conversions (e.g., BINARY hex -> Buffer)
+        let columnDef: any | undefined;
+        if (typeof column === 'string' && column.includes('.')) {
+            const [tableName] = column.split('.', 2);
+            const table = this.config.C6?.TABLES?.[tableName];
+            columnDef = table?.TYPE_VALIDATION?.[column];
+        }
         const val = convertHexIfBinary(column, value, columnDef);
 
         if (this.useNamedParams) {
@@ -141,7 +156,7 @@ export abstract class ConditionBuilder<
             const leftIsRef = this.isTableReference(column);
             const rightIsCol = typeof value === 'string' && this.isColumnRef(value);
 
-            if (!leftIsCol && !rightIsCol) {
+            if (!leftIsCol && !leftIsRef && !rightIsCol) {
                 throw new Error(`Potential SQL injection detected: '${column} ${op} ${value}'`);
             }
 
@@ -222,14 +237,11 @@ export abstract class ConditionBuilder<
 
         const buildFromObject = (obj: Record<string, any>, mode: boolean) => {
             const subParts: string[] = [];
-            for (const [k, v] of Object.entries(obj)) {
-                // numeric keys represent nested OR groups
-                if (!isNaN(Number(k))) {
-                    const sub = this.buildBooleanJoinedConditions(v, false, params);
-                    if (sub) subParts.push(sub);
-                    continue;
-                }
+            const entries = Object.entries(obj);
+            const nonNumeric = entries.filter(([k]) => isNaN(Number(k)));
+            const numeric = entries.filter(([k]) => !isNaN(Number(k)));
 
+            const processEntry = (k: string, v: any) => {
                 if (typeof v === 'object' && v !== null && Object.keys(v).length === 1) {
                     const [op, val] = Object.entries(v)[0];
                     subParts.push(addCondition(k, op, val));
@@ -242,7 +254,18 @@ export abstract class ConditionBuilder<
                 } else {
                     subParts.push(addCondition(k, '=', v));
                 }
+            };
+
+            // Process non-numeric keys first to preserve intuitive insertion order for params
+            for (const [k, v] of nonNumeric) {
+                processEntry(k, v);
             }
+            // Then process numeric keys (treated as grouped OR conditions)
+            for (const [_k, v] of numeric) {
+                const sub = this.buildBooleanJoinedConditions(v, false, params);
+                if (sub) subParts.push(sub);
+            }
+
             return subParts.join(` ${mode ? 'AND' : 'OR'} `);
         };
 

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

@@ -1,4 +1,4 @@
-import {C6Constants} from "api/C6Constants";
+import {C6Constants} from "../../C6Constants";
 import {OrmGenerics} from "../../types/ormGenerics";
 import {JoinBuilder} from "./JoinBuilder";
 
@@ -44,9 +44,15 @@ export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuild
         /* -------- 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}`;
+            const pageRaw = pagination[C6Constants.PAGE];
+            const pageParsed = parseInt(pageRaw ?? 1, 10);
+            const page = isFinite(pageParsed) && pageParsed > 1 ? pageParsed : 1;
+            if (page === 1) {
+                sql += ` LIMIT ${lim}`;
+            } else {
+                const offset = (page - 1) * lim;
+                sql += ` LIMIT ${offset}, ${lim}`;
+            }
         }
 
         this.config.verbose && console.log(`[PAGINATION] ${sql.trim()}`);

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

@@ -9,6 +9,9 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
         isSubSelect: boolean = false
     ): SqlBuilderResult {
         this.aliasMap = {};
+        // reset any previously collected SELECT aliases (from AggregateBuilder)
+        // @ts-ignore
+        if (this.selectAliases && this.selectAliases.clear) this.selectAliases.clear();
         const args = this.request;
         this.initAlias(table, args.JOIN);
         const params = this.useNamedParams ? {} : [];

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

@@ -22,7 +22,8 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             throw new Error("No update data provided in the request.");
         }
 
-        const setClauses = Object.entries(this.request[C6C.UPDATE]).map(([col, val]) => this.addParam(params, col, val));
+        const setClauses = Object.entries(this.request[C6C.UPDATE])
+            .map(([col, val]) => `\`${col}\` = ${this.addParam(params, col, val)}`);
 
         sql += ` SET ${setClauses.join(', ')}`;
 

package/src/api/types/ormInterfaces.ts

@@ -66,7 +66,7 @@ export type Pagination<T = any> = {
     ORDER?: Partial<Record<keyof T, OrderDirection>>;
 };
 
-export type RequestGetPutDeleteBody<T extends { [key: string]: any } = any> = {
+export type RequestGetPutDeleteBody<T extends { [key: string]: any } = any> = T | {
     SELECT?: SelectField<T>[];
     UPDATE?: Partial<T>;
     DELETE?: boolean;
@@ -84,6 +84,7 @@ export type iAPI<T extends { [key: string]: any }> = T & {
     error?: string | ((r: AxiosResponse) => string | void);
 };
 
+// TODO - Eventually I believe we can support complex posts.
 export type RequestQueryBody<
     Method extends iRestMethods,
     T extends { [key: string]: any },
@@ -91,9 +92,7 @@ export type RequestQueryBody<
     Overrides extends { [key: string]: any } = {}
 > = 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>;
+    : iAPI<Modify<T, Overrides> & Custom>;
 
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;

package/src/api/utils/cacheManager.ts

@@ -1,5 +1,5 @@
 import {AxiosPromise} from "axios";
-import { iCacheAPI } from "api/types/ormInterfaces";
+import { iCacheAPI } from "../types/ormInterfaces";
 
 // do not remove entries from this array. It is used to track the progress of API requests.
 // position in array is important. Do not sort. To not add to begging.