@carbonorm/carbonnode 3.11.0 → 4.0.1

package/src/api/executors/HttpExecutor.ts

@@ -8,14 +8,13 @@ import {OrmGenerics} from "../types/ormGenerics";
 import {
     DELETE, DetermineResponseDataType,
     GET,
-    iCacheAPI,
     iConstraint,
-    iGetC6RestResponse,
+    C6RestResponse,
     POST,
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
-import {apiRequestCache, checkCache, userCustomClearCache} from "../utils/cacheManager";
+import {checkCache, setCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
@@ -27,8 +26,11 @@ export class HttpExecutor<
 
     private isRestResponse<T extends Record<string, any>>(
         r: AxiosResponse<any>
-    ): r is AxiosResponse<iGetC6RestResponse<T>> {
-        return !!r && r.data != null && typeof r.data === 'object' && 'rest' in r.data;
+    ): r is AxiosResponse<C6RestResponse<'GET', T>> {
+        return !!r
+            && r.data != null
+            && typeof r.data === 'object'
+            && Array.isArray((r.data as C6RestResponse<'GET', T>).rest);
     }
 
     private stripTableNameFromKeys<T extends Record<string, any>>(obj: Partial<T> | undefined | null): Partial<T> {
@@ -182,20 +184,6 @@ export class HttpExecutor<
             console.groupEnd()
         }
 
-        // an undefined query would indicate queryCallback returned undefined,
-        // thus the request shouldn't fire as is in custom cache
-        if (undefined === this.request || null === this.request) {
-
-            if (isLocal()) {
-                console.groupCollapsed(`API: (${requestMethod}) (${tableName}) query undefined/null → returning null`)
-                console.log('request', this.request)
-                console.groupEnd()
-            }
-
-            return null;
-
-        }
-
         let query = this.request;
 
         // this is parameterless and could return itself with a new page number, or undefined if the end is reached
@@ -219,14 +207,6 @@ export class HttpExecutor<
                 console.groupEnd()
             }
 
-            // The problem with creating cache keys with a stringified object is the order of keys matters and it's possible for the same query to be stringified differently.
-            // Here we ensure the key order will be identical between two of the same requests. https://stackoverflow.com/questions/5467129/sort-javascript-object-by-key
-
-            // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
-            let querySerialized: string = sortAndSerializeQueryObject(tables, query ?? {});
-
-            let cacheResult: iCacheAPI | undefined = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized);
-
             let cachingConfirmed = false;
 
             // determine if we need to paginate.
@@ -253,52 +233,42 @@ export class HttpExecutor<
 
                 query[C6.PAGINATION][C6.LIMIT] = query[C6.PAGINATION][C6.LIMIT] || 100;
 
-                // this will evaluate true most the time
-                if (true === cacheResults) {
-                    if (undefined !== cacheResult) {
-                        do {
-                            const cacheCheck = checkCache<ResponseDataType>(cacheResult, requestMethod, tableName, this.request);
-                            if (false !== cacheCheck) {
-                                return (await cacheCheck).data;
-                            }
-                            ++query[C6.PAGINATION][C6.PAGE];
-                            querySerialized = sortAndSerializeQueryObject(tables, query ?? {});
-                            cacheResult = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized)
-                        } while (undefined !== cacheResult)
-                        if (debug && isLocal()) {
-                            toast.warning("DEVS: Request pages exhausted in cache; firing network.", toastOptionsDevs);
-                        }
-                    }
-                    cachingConfirmed = true;
-                } else {
-                    if (debug && isLocal()) toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
-                }
-
-                if (debug && isLocal()) {
-                    toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? " Page (" + query[C6.PAGINATION][C6.PAGE] + ")" : ''), toastOptionsDevs);
-                }
+            }
 
-            } else if (cacheResults) { // if we are not getting, we are updating, deleting, or inserting
+            // The problem with creating cache keys with a stringified object is the order of keys matters and it's possible for the same query to be stringified differently.
+            // Here we ensure the key order will be identical between two of the same requests. https://stackoverflow.com/questions/5467129/sort-javascript-object-by-key
+            const cacheRequestData = JSON.parse(JSON.stringify(query ?? {})) as RequestQueryBody<
+                G['RequestMethod'],
+                G['RestTableInterface'],
+                G['CustomAndRequiredFields'],
+                G['RequestTableOverrides']
+            >;
 
-                if (cacheResult) {
-                    const cacheCheck = checkCache<ResponseDataType>(cacheResult, requestMethod, tableName, this.request);
+            // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
+            let querySerialized: string = sortAndSerializeQueryObject(tables, cacheRequestData ?? {});
 
-                    if (false !== cacheCheck) {
+            let cachedRequest: AxiosPromise<ResponseDataType> | false = false;
 
-                        return (await cacheCheck).data;
+            if (cacheResults) {
+                cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData);
+            }
 
-                    }
-                }
+            if (cachedRequest) {
+                return (await cachedRequest).data;
+            }
 
+            if (cacheResults) {
                 cachingConfirmed = true;
-                // push to cache so we do not repeat the request
+            } else if (debug && isLocal()) {
+                toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
+            }
 
+            if (cacheResults && debug && isLocal()) {
+                toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? " Page (" + query[C6.PAGINATION][C6.PAGE] + ")" : ''), toastOptionsDevs);
             }
 
             let apiResponse: G['RestTableInterface'][G['PrimaryKey']] | string | boolean | number | undefined;
 
-            let returnGetNextPageFunction = false;
-
             let restRequestUri: string = restURL + operatingTable + '/';
 
             const needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
@@ -460,22 +430,30 @@ export class HttpExecutor<
 
 
                 if (cachingConfirmed) {
-
-                    // push to cache so we do not repeat the request
-                    apiRequestCache.push({
+                    setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                         requestArgumentsSerialized: querySerialized,
-                        request: axiosActiveRequest
+                        request: axiosActiveRequest,
                     });
-
                 }
 
                 // returning the promise with this then is important for tests. todo - we could make that optional.
                 // https://rapidapi.com/guides/axios-async-await
                 return axiosActiveRequest.then(async (response: AxiosResponse<ResponseDataType, any>): Promise<AxiosResponse<ResponseDataType, any>> => {
 
+                        let hasNext: boolean | undefined;
+
                         // noinspection SuspiciousTypeOfGuard
                         if (typeof response.data === 'string') {
 
+                            if (cachingConfirmed) {
+                                setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                    requestArgumentsSerialized: querySerialized,
+                                    request: axiosActiveRequest,
+                                    response,
+                                    final: true,
+                                });
+                            }
+
                             if (isTest()) {
 
                                 console.trace()
@@ -489,15 +467,11 @@ export class HttpExecutor<
                         }
 
                         if (cachingConfirmed) {
-
-                            const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
-
-                            // TODO - currently nonthing is setting this correctly
-                            apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
-
-                            // only cache get method requests
-                            apiRequestCache[cacheIndex].response = response
-
+                            setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                requestArgumentsSerialized: querySerialized,
+                                request: axiosActiveRequest,
+                                response,
+                            });
                         }
 
                         this.runLifecycleHooks<"afterExecution">(
@@ -549,27 +523,30 @@ export class HttpExecutor<
                             callback();
                         }
 
-                        if (C6.GET === requestMethod && this.isRestResponse<any>(response)) {
+                        if (C6.GET === requestMethod && this.isRestResponse(response)) {
 
                             const responseData = response.data;
 
                             const pageLimit = query?.[C6.PAGINATION]?.[C6.LIMIT];
+
                             const got = responseData.rest.length;
-                            const hasNext = pageLimit !== 1 && got === pageLimit;
+                            hasNext = pageLimit !== 1 && got === pageLimit;
 
                             if (hasNext) {
-                                responseData.next = apiRequest;   // there might be more
+                                responseData.next = apiRequest as () => Promise<
+                                    DetermineResponseDataType<'GET', G['RestTableInterface']>
+                                >;
                             } else {
                                 responseData.next = undefined;    // short page => done
                             }
 
-                            // If you keep this flag, make it reflect reality:
-                            returnGetNextPageFunction = hasNext;
-
-                            // and fix cache ‘final’ flag to match:
                             if (cachingConfirmed) {
-                                const cacheIndex = apiRequestCache.findIndex(c => c.requestArgumentsSerialized === querySerialized);
-                                apiRequestCache[cacheIndex].final = !hasNext;
+                                setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                    requestArgumentsSerialized: querySerialized,
+                                    request: axiosActiveRequest,
+                                    response,
+                                    final: !hasNext,
+                                });
                             }
 
                             if ((this.config.verbose || debug) && isLocal()) {
@@ -580,11 +557,9 @@ export class HttpExecutor<
                             }
 
                             // next already set above based on hasNext; avoid duplicate, inverted logic
-
-
                             if (fetchDependencies
                                 && 'number' === typeof fetchDependencies
-                                && responseData.rest.length > 0) {
+                                && responseData.rest?.length > 0) {
 
                                 console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')'
                                     + (fetchDependencies & eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
@@ -827,6 +802,15 @@ export class HttpExecutor<
 
                         }
 
+                        if (cachingConfirmed && hasNext === undefined) {
+                            setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                requestArgumentsSerialized: querySerialized,
+                                request: axiosActiveRequest,
+                                response,
+                                final: true,
+                            });
+                        }
+
                         if (debug && isLocal()) {
 
                             toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
@@ -841,25 +825,17 @@ export class HttpExecutor<
 
             } catch (throwableError) {
 
-                if (isTest()) {
-
-                    throw new Error(JSON.stringify(throwableError))
-
-                }
-
                 console.groupCollapsed('%c API: An error occurred in the try catch block. returning null!', 'color: #ff0000')
 
                 console.log('%c ' + requestMethod + ' ' + tableName, 'color: #A020F0')
 
-                console.warn(throwableError)
+                console.error(throwableError)
 
                 console.trace()
 
                 console.groupEnd()
 
-                TestRestfulResponse(throwableError, success, error)
-
-                return null;
+                throw new Error(JSON.stringify(throwableError))
 
             }
 

package/src/api/handlers/ExpressHandler.ts

@@ -13,7 +13,7 @@ export function ExpressHandler({C6, mysqlPool}: { C6: iC6Object, mysqlPool: Pool
         try {
             const incomingMethod = req.method.toUpperCase() as iRestMethods;
             const table = req.params.table;
-            const primary = req.params.primary;
+            let primary = req.params.primary;
             // Support Axios interceptor promoting large GETs to POST with ?METHOD=GET
             const methodOverrideRaw = (req.query?.METHOD ?? req.query?.method) as unknown;
             const methodOverride = typeof methodOverrideRaw === 'string' ? methodOverrideRaw.toUpperCase() : undefined;
@@ -38,17 +38,40 @@ export function ExpressHandler({C6, mysqlPool}: { C6: iC6Object, mysqlPool: Pool
                 return;
             }
 
-            const primaryKeys = C6.TABLES[table].PRIMARY;
+            const restModel = C6.TABLES[table];
+            const primaryKeys = restModel.PRIMARY;
+            const primaryShortKeys = restModel.PRIMARY_SHORT ?? [];
+            const columnMap = restModel.COLUMNS ?? {};
+            const resolveShortKey = (fullKey: string, index: number) =>
+                (columnMap as any)[fullKey] ?? primaryShortKeys[index] ?? fullKey.split('.').pop() ?? fullKey;
+            const hasPrimaryKeyValues = (data: any) => {
+                if (!data || typeof data !== 'object') return false;
+                const whereClause = (data as any)[C6C.WHERE];
+                const hasKeyValue = (obj: any, fullKey: string, shortKey: string) => {
+                    if (!obj || typeof obj !== 'object') return false;
+                    const fullValue = obj[fullKey];
+                    if (fullValue !== undefined && fullValue !== null) return true;
+                    const shortValue = shortKey ? obj[shortKey] : undefined;
+                    return shortValue !== undefined && shortValue !== null;
+                };
+                return primaryKeys.every((fullKey, index) => {
+                    const shortKey = resolveShortKey(fullKey, index);
+                    return hasKeyValue(whereClause, fullKey, shortKey) || hasKeyValue(data, fullKey, shortKey);
+                });
+            };
 
             if (primary && primaryKeys.length !== 1) {
-                if (primaryKeys.length > 1) {
+                if (primaryKeys.length > 1 && hasPrimaryKeyValues(payload)) {
+                    primary = undefined;
+                } else if (primaryKeys.length > 1) {
                     res.status(400).json({error: `Table ${table} has multiple primary keys. Cannot implicitly determine key.`});
                     return;
+                } else {
+                    res.status(400).json({
+                        error: `Table ${table} has no primary keys. Please specify one.`
+                    });
+                    return;
                 }
-                res.status(400).json({
-                    error: `Table ${table} has no primary keys. Please specify one.`
-                });
-                return;
             }
 
             const primaryKeyName = primaryKeys[0];

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

@@ -378,6 +378,80 @@ export abstract class ConditionBuilder<
         throw new Error('Unsupported operand type in SQL expression.');
     }
 
+    private isPlainArrayLiteral(value: any, allowColumnRefs = false): boolean {
+        if (!Array.isArray(value)) return false;
+        return value.every(item => {
+            if (item === null) return true;
+            const type = typeof item;
+            if (type === 'string' || type === 'number' || type === 'boolean') return true;
+            if (Array.isArray(item)) return this.isPlainArrayLiteral(item, allowColumnRefs);
+            if (item && typeof item === 'object') return this.isPlainObjectLiteral(item, allowColumnRefs);
+            return false;
+        });
+    }
+
+    private isPlainObjectLiteral(value: any, allowColumnRefs = false): boolean {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+        if (value instanceof Date) return false;
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) return false;
+
+        const normalized = value instanceof Map ? Object.fromEntries(value) : value;
+        if (C6C.SUBSELECT in (normalized as any)) return false;
+
+        const entries = Object.entries(normalized as Record<string, any>);
+        if (entries.length === 0) return true;
+
+        if (entries.some(([key]) => this.isOperator(key) || this.BOOLEAN_OPERATORS.has(key))) {
+            return false;
+        }
+
+        if (!allowColumnRefs) {
+            if (entries.some(([key]) => typeof key === 'string' && (this.isColumnRef(key) || key.includes('.')))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private resolveColumnDefinition(column?: string): any | undefined {
+        if (!column || typeof column !== 'string' || !column.includes('.')) return undefined;
+        const [prefix, colName] = column.split('.', 2);
+        const tableName = this.aliasMap[prefix] ?? prefix;
+        const table = this.config.C6?.TABLES?.[tableName];
+        if (!table?.TYPE_VALIDATION) return undefined;
+        return table.TYPE_VALIDATION[colName] ?? table.TYPE_VALIDATION[`${tableName}.${colName}`];
+    }
+
+    private isJsonColumn(column?: string): boolean {
+        const columnDef = this.resolveColumnDefinition(column);
+        const mysqlType = columnDef?.MYSQL_TYPE;
+        return typeof mysqlType === 'string' && mysqlType.toLowerCase().includes('json');
+    }
+
+    protected serializeUpdateValue(
+        value: any,
+        params: any[] | Record<string, any>,
+        contextColumn?: string
+    ): string {
+        const normalized = value instanceof Map ? Object.fromEntries(value) : value;
+
+        const allowColumnRefs = this.isJsonColumn(contextColumn);
+
+        if (this.isPlainArrayLiteral(normalized, allowColumnRefs)
+            || this.isPlainObjectLiteral(normalized, allowColumnRefs)) {
+            return this.addParam(params, contextColumn ?? '', JSON.stringify(normalized));
+        }
+
+        const { sql, isReference, isExpression, isSubSelect } = this.serializeOperand(normalized, params, contextColumn);
+
+        if (!isReference && !isExpression && !isSubSelect && typeof normalized === 'object' && normalized !== null) {
+            throw new Error('Unsupported operand type in SQL expression.');
+        }
+
+        return sql;
+    }
+
     private ensurePlainObject<T>(value: T): any {
         if (value instanceof Map) {
             return Object.fromEntries(value as unknown as Map<string, any>);

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

@@ -18,13 +18,15 @@ export class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G>
         const verb = C6C.REPLACE in this.request ? C6C.REPLACE : C6C.INSERT;
         const body = verb in this.request ? this.request[verb] : this.request;
         const keys = Object.keys(body);
-        const params: any[] = []
+        const params: any[] | Record<string, any> = this.useNamedParams ? {} : [];
         const placeholders: string[] = []
 
 
         for (const key of keys) {
             const value = body[key];
-            const placeholder = this.addParam(params, key, value);
+            const trimmed = this.trimTablePrefix(table, key);
+            const qualified = `${table}.${trimmed}`;
+            const placeholder = this.serializeUpdateValue(value, params, qualified);
             placeholders.push(placeholder);
         }
 

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

@@ -39,7 +39,9 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             .map(([col, val]) => {
                 const trimmed = this.trimTablePrefix(table, col);
                 const qualified = `${table}.${trimmed}`;
-                return `\`${trimmed}\` = ${this.addParam(params, qualified, val)}`;
+                this.assertValidIdentifier(qualified, 'UPDATE SET');
+                const rightSql = this.serializeUpdateValue(val, params, qualified);
+                return `\`${trimmed}\` = ${rightSql}`;
             });
 
         sql += ` SET ${setClauses.join(', ')}`;

package/src/api/types/ormInterfaces.ts

@@ -97,7 +97,13 @@ export type RequestQueryBody<
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;
     request: AxiosPromise<ResponseDataType>;
-    response?: AxiosResponse;
+    response?: AxiosResponse & {
+        __carbonTiming?: {
+            start: number;
+            end: number;
+            duration: number;
+        }
+    },
     final?: boolean;
 }
 
@@ -105,40 +111,48 @@ export interface iChangeC6Data {
     rowCount: number;
 }
 
-export interface iDeleteC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
+// New discriminated REST response type based on HTTP method
+export type C6RestResponse<
+    Method extends iRestMethods,
+    RestData extends { [key: string]: any },
+    Overrides = {}
+> = {
+    rest: Method extends 'GET' ? Modify<RestData, Overrides>[] : Modify<RestData, Overrides>;
+    session?: any;
+    sql?: any;
+} & (Method extends 'GET'
+    ? { next?: () => Promise<DetermineResponseDataType<'GET', RestData, Overrides>> }
+    : {});
+
+export interface iC6RestResponse<RestData> {
+    // Backwards compatibility: base interface for rest/sql/session (singular)
+    rest: RestData;
+    session?: any;
+    sql?: any;
+}
+
+export interface iDeleteC6RestResponse<RestData extends { [key: string]: any; }, RequestData = any> extends iChangeC6Data, C6RestResponse<'DELETE', RestData> {
     deleted: boolean | number | string | RequestData;
 }
 
-export interface iPostC6RestResponse<RestData = any> extends iC6RestResponse<RestData> {
+export interface iPostC6RestResponse<RestData extends { [key: string]: any; }> extends C6RestResponse<'POST', RestData> {
     created: boolean | number | string;
 }
 
-export interface iPutC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
+export interface iPutC6RestResponse<RestData extends { [key: string]: any; }, RequestData = any> extends iChangeC6Data, C6RestResponse<'PUT', RestData> {
     updated: boolean | number | string | RequestData;
 }
 
-export interface iC6RestResponse<RestData> {
-    rest: RestData;
-    session?: any;
-    sql?: any;
-}
-
 export interface iGetC6RestResponse<
     ResponseDataType extends { [key: string]: any },
     ResponseDataOverrides = {}
-> extends iC6RestResponse<
-    // TODO - We removed Modify<ResponseDataType, ResponseDataOverrides> |
-    Modify<ResponseDataType, ResponseDataOverrides>[]
-> {
-    next?: () => Promise<DetermineResponseDataType<"GET", ResponseDataType, ResponseDataOverrides>>;
-}
+> extends C6RestResponse<'GET', ResponseDataType, ResponseDataOverrides> {}
 
 export type DetermineResponseDataType<
     Method extends iRestMethods,
     RestTableInterface extends { [key: string]: any },
     ResponseDataOverrides = {}
-> = null |
-    (Method extends 'POST'
+> = (Method extends 'POST'
         ? iPostC6RestResponse<RestTableInterface>
         : Method extends 'GET'
             ? iGetC6RestResponse<RestTableInterface, ResponseDataOverrides>