@carbonorm/carbonnode 3.11.0 → 4.0.0

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,60 @@ export abstract class ConditionBuilder<
         throw new Error('Unsupported operand type in SQL expression.');
     }
 
+    private isPlainArrayLiteral(value: any): 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);
+            if (item && typeof item === 'object') return this.isPlainObjectLiteral(item);
+            return false;
+        });
+    }
+
+    private isPlainObjectLiteral(value: any): 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 (entries.some(([key]) => typeof key === 'string' && (this.isColumnRef(key) || key.includes('.')))) {
+            return false;
+        }
+
+        return true;
+    }
+
+    protected serializeUpdateValue(
+        value: any,
+        params: any[] | Record<string, any>,
+        contextColumn?: string
+    ): string {
+        const normalized = value instanceof Map ? Object.fromEntries(value) : value;
+
+        if (this.isPlainArrayLiteral(normalized) || this.isPlainObjectLiteral(normalized)) {
+            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>

package/src/api/utils/cacheManager.ts

@@ -1,46 +1,87 @@
-import {AxiosPromise} from "axios";
+import { AxiosPromise } from "axios";
 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.
-export let apiRequestCache: iCacheAPI[] = [];
-
-export let userCustomClearCache: (() => void)[] = [];
-
-interface iClearCache {
-    ignoreWarning: boolean
-}
-
-export function clearCache(props?: iClearCache) {
-
-    if (false === props?.ignoreWarning) {
-
-        console.warn('The rest api clearCache should only be used with extreme care! Avoid using this in favor of using `cacheResults : boolean`.')
-
+// -----------------------------------------------------------------------------
+// Cache Storage
+// -----------------------------------------------------------------------------
+export const apiRequestCache = new Map<string, iCacheAPI>();
+export const userCustomClearCache: (() => void)[] = [];
+
+// -----------------------------------------------------------------------------
+// Cache Key Generator (safe, fixed-size ~40 chars)
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Browser-safe deterministic hash (FNV-1a)
+// -----------------------------------------------------------------------------
+function fnv1a(str: string): string {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
     }
-
-    userCustomClearCache.map((f) => 'function' === typeof f && f());
-
-    userCustomClearCache = apiRequestCache = []
-
+    return h.toString(16);
 }
 
-export function checkCache<ResponseDataType = any, RestShortTableNames = string>(cacheResult: iCacheAPI<ResponseDataType>, requestMethod: string, tableName: RestShortTableNames | RestShortTableNames[], request: any): false | AxiosPromise<ResponseDataType> {
-
-    if (undefined === cacheResult) {
-
-        return false;
+function makeCacheKey(
+    method: string,
+    tableName: string | string[],
+    requestData: unknown,
+): string {
+    const raw = JSON.stringify([method, tableName, requestData]);
+    return fnv1a(raw);
+}
 
+// -----------------------------------------------------------------------------
+// Clear Cache (no shared-array bugs)
+// -----------------------------------------------------------------------------
+export function clearCache(props?: { ignoreWarning?: boolean }): void {
+    if (!props?.ignoreWarning) {
+        console.warn(
+            "The REST API clearCache should only be used with extreme care!",
+        );
     }
 
-    console.groupCollapsed('%c API: The request on (' + tableName + ') is in cache. Returning the request Promise!', 'color: #0c0')
-
-    console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
-
-    console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request)
+    for (const fn of userCustomClearCache) {
+        try {
+            fn();
+        } catch {}
+    }
 
-    console.groupEnd()
+    apiRequestCache.clear();
+}
 
-    return cacheResult.request;
+// -----------------------------------------------------------------------------
+// Check Cache (dedupe via hashed key)
+// -----------------------------------------------------------------------------
+export function checkCache<ResponseDataType = any>(
+    method: string,
+    tableName: string | string[],
+    requestData: any,
+): AxiosPromise<ResponseDataType> | false {
+    const key = makeCacheKey(method, tableName, requestData);
+    const cached = apiRequestCache.get(key);
+
+    if (!cached) return false;
+
+    console.groupCollapsed(
+        `%c API cache hit for ${method} ${tableName}`,
+        "color:#0c0",
+    );
+    console.log("Request Data:", requestData);
+    console.groupEnd();
+
+    return cached.request;
+}
 
+// -----------------------------------------------------------------------------
+// Store Cache Entry (drop-in compatible)
+// -----------------------------------------------------------------------------
+export function setCache<ResponseDataType = any>(
+    method: string,
+    tableName: string | string[],
+    requestData: any,
+    cacheEntry: iCacheAPI<ResponseDataType>,
+): void {
+    const key = makeCacheKey(method, tableName, requestData);
+    apiRequestCache.set(key, cacheEntry);
 }

package/src/api/utils/testHelpers.ts

@@ -2,13 +2,15 @@ import {apiRequestCache} from "./cacheManager";
 
 export function checkAllRequestsComplete(): true | (string[]) {
 
-    const stillRunning = apiRequestCache.filter((cache) => undefined === cache.response)
+    const cacheEntries = Array.from(apiRequestCache.values())
+
+    const stillRunning = cacheEntries.filter((cache) => undefined === cache.response)
 
     if (stillRunning.length !== 0) {
 
         if (document === null || document === undefined) {
 
-            throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(apiRequestCache) + ')')
+            throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(cacheEntries) + ')')
 
         }
 
@@ -21,4 +23,4 @@ export function checkAllRequestsComplete(): true | (string[]) {
 
     return true
 
-}
+}

package/src/variables/isNode.ts

@@ -1,12 +1,5 @@
 const isNode =  () => {
-
-    console.log('Checking if running in Node.js environment...');
-
-    const isNodeEnv = typeof process !== 'undefined' && !!process.versions?.node;
-
-    console.log(`Is Node.js environment: ${isNodeEnv}`);
-
-    return isNodeEnv;
+    return typeof process !== 'undefined' && !!process.versions?.node;
 }
 
 export default isNode;