@carbonorm/carbonnode 3.10.0 → 4.0.0

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

@@ -107,9 +107,18 @@ export abstract class ConditionBuilder<
         [C6C.BETWEEN, C6C.BETWEEN],
         ['BETWEEN', C6C.BETWEEN],
         ['NOT BETWEEN', 'NOT BETWEEN'],
+        [C6C.EXISTS, C6C.EXISTS],
+        ['EXISTS', C6C.EXISTS],
+        ['NOT EXISTS', 'NOT EXISTS'],
         [C6C.MATCH_AGAINST, C6C.MATCH_AGAINST],
     ]);
 
+    private readonly BOOLEAN_FUNCTION_KEYS = new Set<string>([
+        C6C.ST_CONTAINS?.toUpperCase?.() ?? 'ST_CONTAINS',
+        C6C.ST_WITHIN?.toUpperCase?.() ?? 'ST_WITHIN',
+        C6C.MBRCONTAINS?.toUpperCase?.() ?? 'MBRCONTAINS',
+    ]);
+
     private isTableReference(val: any): boolean {
         if (typeof val !== 'string') return false;
         // Support aggregate aliases (e.g., SELECT COUNT(x) AS cnt ... HAVING cnt > 1)
@@ -313,6 +322,10 @@ export abstract class ConditionBuilder<
             return { sql: asParam(operand), isReference: false, isExpression: false, isSubSelect: false };
         }
 
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(operand)) {
+            return { sql: asParam(operand), isReference: false, isExpression: false, isSubSelect: false };
+        }
+
         if (typeof operand === 'string') {
             if (this.isTableReference(operand) || this.isColumnRef(operand)) {
                 return { sql: operand, isReference: true, isExpression: false, isSubSelect: false };
@@ -365,6 +378,197 @@ 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>);
+        }
+        return value;
+    }
+
+    private resolveExistsInnerColumn(subRequest: Record<string, any>, provided?: string): string {
+        if (provided) {
+            if (typeof provided !== 'string' || provided.trim() === '') {
+                throw new Error('EXISTS correlation column must be a non-empty string.');
+            }
+            return provided;
+        }
+
+        const selectClause = this.ensurePlainObject(subRequest?.[C6C.SELECT]);
+        if (Array.isArray(selectClause) && selectClause.length > 0) {
+            const candidate = selectClause[0];
+            if (typeof candidate === 'string' && candidate.trim() !== '') {
+                return candidate;
+            }
+        }
+
+        const fromTable = subRequest?.[C6C.FROM];
+        if (typeof fromTable === 'string' && fromTable.trim() !== '') {
+            const table = this.config.C6?.TABLES?.[fromTable.trim()];
+            const primary = table?.PRIMARY;
+            if (Array.isArray(primary) && primary.length > 0) {
+                return String(primary[0]);
+            }
+        }
+
+        throw new Error('EXISTS requires a correlation column to be provided or inferable from the subselect.');
+    }
+
+    private normalizeExistsSpec(
+        spec: any
+    ): { outerColumn: string; subRequest: Record<string, any>; innerColumn?: string } {
+        const normalized = this.ensurePlainObject(spec);
+
+        if (!Array.isArray(normalized) || normalized.length < 2) {
+            throw new Error('EXISTS expects an array like [outerColumn, subselect, innerColumn?].');
+        }
+
+        const [outerRaw, payloadRaw, innerRaw] = normalized;
+        if (typeof outerRaw !== 'string' || outerRaw.trim() === '') {
+            throw new Error('EXISTS requires the first element to be an outer column reference string.');
+        }
+
+        const payload = this.ensurePlainObject(payloadRaw);
+        let subSelect: any;
+        if (payload && typeof payload === 'object' && C6C.SUBSELECT in payload) {
+            subSelect = this.ensurePlainObject(payload[C6C.SUBSELECT]);
+        } else if (payload && typeof payload === 'object') {
+            subSelect = payload;
+        } else {
+            throw new Error('EXISTS requires a subselect payload as the second element.');
+        }
+
+        if (!subSelect || typeof subSelect !== 'object') {
+            throw new Error('EXISTS subselect payload must be an object.');
+        }
+
+        const innerColumn = typeof innerRaw === 'string' ? innerRaw : undefined;
+
+        return {
+            outerColumn: outerRaw,
+            subRequest: { ...subSelect },
+            innerColumn,
+        };
+    }
+
+    private buildExistsExpression(
+        spec: any,
+        operator: string,
+        params: any[] | Record<string, any>
+    ): string {
+        const { outerColumn, subRequest, innerColumn } = this.normalizeExistsSpec(spec);
+
+        const fromTableRaw = subRequest[C6C.FROM];
+        if (typeof fromTableRaw !== 'string' || fromTableRaw.trim() === '') {
+            throw new Error('EXISTS subselect requires a table specified with C6C.FROM.');
+        }
+        const fromTable = fromTableRaw.trim();
+
+        this.assertValidIdentifier(outerColumn, 'EXISTS correlation column');
+        const correlationColumn = this.resolveExistsInnerColumn(subRequest, innerColumn);
+        if (!this.isColumnRef(correlationColumn) && !this.isTableReference(correlationColumn)) {
+            throw new Error(`Unknown column reference '${correlationColumn}' used in EXISTS subquery correlation column.`);
+        }
+
+        const existingWhereRaw = this.ensurePlainObject(subRequest[C6C.WHERE]);
+        const correlationCondition = { [correlationColumn]: [C6C.EQUAL, outerColumn] };
+
+        const normalizedExistingWhere = existingWhereRaw && typeof existingWhereRaw === 'object'
+            ? Array.isArray(existingWhereRaw)
+                ? existingWhereRaw.slice()
+                : { ...(existingWhereRaw as Record<string, any>) }
+            : existingWhereRaw;
+
+        const hasExistingWhere = Array.isArray(normalizedExistingWhere)
+            ? normalizedExistingWhere.length > 0
+            : normalizedExistingWhere && typeof normalizedExistingWhere === 'object'
+                ? Object.keys(normalizedExistingWhere).length > 0
+                : normalizedExistingWhere != null;
+
+        let whereClause: any;
+        if (!hasExistingWhere) {
+            whereClause = correlationCondition;
+        } else if (
+            normalizedExistingWhere && typeof normalizedExistingWhere === 'object' &&
+            Object.keys(normalizedExistingWhere).some(key => this.BOOLEAN_OPERATORS.has(key))
+        ) {
+            whereClause = { [C6C.AND]: [normalizedExistingWhere, correlationCondition] };
+        } else if (normalizedExistingWhere && typeof normalizedExistingWhere === 'object') {
+            whereClause = { ...normalizedExistingWhere, ...correlationCondition };
+        } else {
+            whereClause = { [C6C.AND]: [normalizedExistingWhere, correlationCondition] };
+        }
+
+        const subRequestWithCorrelation = {
+            ...subRequest,
+            [C6C.FROM]: fromTable,
+            [C6C.WHERE]: whereClause,
+            [C6C.SELECT]: subRequest[C6C.SELECT] ?? ['1'],
+        };
+
+        const buildScalarSubSelect = (this as any).buildScalarSubSelect;
+        if (typeof buildScalarSubSelect !== 'function') {
+            throw new Error('EXISTS operator requires SelectQueryBuilder context.');
+        }
+
+        const scalar = buildScalarSubSelect.call(this, subRequestWithCorrelation, params);
+        const keyword = operator === 'NOT EXISTS' ? 'NOT EXISTS' : C6C.EXISTS;
+        return `${keyword} ${scalar}`;
+    }
+
     private buildOperatorExpression(
         op: string,
         rawOperands: any,
@@ -373,6 +577,15 @@ export abstract class ConditionBuilder<
     ): string {
         const operator = this.formatOperator(op);
 
+        if (operator === C6C.EXISTS || operator === 'NOT EXISTS') {
+            const operands = Array.isArray(rawOperands) ? rawOperands : [rawOperands];
+            if (!operands.length) {
+                throw new Error(`${operator} requires at least one subselect specification.`);
+            }
+            const clauses = operands.map(spec => this.buildExistsExpression(spec, operator, params));
+            return this.joinBooleanParts(clauses, 'AND');
+        }
+
         if (operator === C6C.MATCH_AGAINST) {
             if (!Array.isArray(rawOperands) || rawOperands.length !== 2) {
                 throw new Error('MATCH_AGAINST requires an array of two operands.');
@@ -497,6 +710,20 @@ export abstract class ConditionBuilder<
             value = Object.fromEntries(value);
         }
 
+        if (typeof column === 'string') {
+            const normalizedColumn = column.trim().toUpperCase();
+            if (this.BOOLEAN_FUNCTION_KEYS.has(normalizedColumn)) {
+                if (!Array.isArray(value)) {
+                    throw new Error(`${column} expects an array of arguments.`);
+                }
+                return this.buildFunctionCall(column, value, params);
+            }
+        }
+
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) {
+            return this.buildOperatorExpression(C6C.EQUAL, [column, value], params, column);
+        }
+
         if (Array.isArray(value)) {
             if (value.length >= 2 && typeof value[0] === 'string') {
                 const [op, ...rest] = value;