@loopstack/core 0.8.1 → 0.9.0

package/dist/modules/common/services/expression-handler/object-expression.handler.js

@@ -5,9 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 var ObjectExpressionHandler_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectExpressionHandler = void 0;
@@ -16,581 +13,68 @@ const lodash_1 = require("lodash");
 const object_expression_error_1 = require("../../errors/object-expression.error");
 let ObjectExpressionHandler = ObjectExpressionHandler_1 = class ObjectExpressionHandler {
     logger = new common_1.Logger(ObjectExpressionHandler_1.name);
-    DEFAULT_MAX_DEPTH = 10;
-    DEFAULT_MAX_LENGTH = 1000;
-    RESOURCE_LIMITS = {
-        maxIterations: 1000,
-        maxMemoryMB: 128,
-        timeoutMs: 5000,
-        maxDataSize: 1024 * 1024,
-        maxObjectDepth: 10,
-    };
     EXPRESSION_PATTERN = /^\$\{(.+)\}$/;
-    FUNCTION_PATTERN = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*(.*?)\s*\)$/;
-    VALID_SEGMENT_PATTERN = /^[a-zA-Z0-9_-]+(\[\d+\])?$/;
+    MAX_EXPRESSION_LENGTH = 1000;
+    MAX_DEPTH = 10;
     FORBIDDEN_PROPERTIES = new Set([
         '__proto__',
         'constructor',
         'prototype',
-        '__defineGetter__',
-        '__defineSetter__',
-        '__lookupGetter__',
-        '__lookupSetter__',
-        'hasOwnProperty',
-        'isPrototypeOf',
-        'propertyIsEnumerable',
-        'toString',
-        'valueOf',
-        'console',
-        'Buffer',
-        'window',
-        'global',
-        'process',
-        'import',
-        'require',
-        'function',
-        'eval',
     ]);
-    functions = new Map();
-    constructor() {
-        this.registerBuiltInFunctions();
-    }
     canHandle(value) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-        const trimmed = value.trim();
-        return this.EXPRESSION_PATTERN.test(trimmed);
+        return typeof value === 'string' && this.EXPRESSION_PATTERN.test(value.trim());
     }
     process(content, variables) {
         try {
-            const context = {
-                variables,
-                depth: 0,
-            };
-            return this.processExpression(content, context);
+            const expression = this.extractExpression(content);
+            this.validateExpression(expression);
+            return this.evaluateExpression(expression, variables);
         }
         catch (error) {
-            this.logger.error(`Failed to process object expression: ${error.message}`);
-            this.logger.debug('Expression processing failed', {
-                expression: content.substring(0, 100),
-                errorType: error.constructor.name,
-                errorCode: error instanceof object_expression_error_1.ObjectExpressionError ? error.code : 'UNKNOWN',
-                variableKeys: Object.keys(variables).slice(0, 10),
-                expressionLength: content.length,
-                timestamp: new Date().toISOString(),
-            });
             if (error instanceof object_expression_error_1.ObjectExpressionError) {
                 throw error;
             }
+            this.logger.error(`Expression processing failed: ${error.message}`);
             throw new object_expression_error_1.ObjectExpressionError('Object expression evaluation failed', 'EVALUATION_ERROR');
         }
     }
-    processExpression(content, context) {
-        const expression = this.extractExpression(content);
-        this.validateExpression(expression);
-        return this.evaluateExpression(expression, context.variables);
-    }
     extractExpression(content) {
-        const trimmed = content.trim();
-        const match = trimmed.match(this.EXPRESSION_PATTERN);
-        if (!match || !match[1]) {
-            this.logger.debug('Expression format validation failed', {
-                content: trimmed.substring(0, 50),
-                patternUsed: this.EXPRESSION_PATTERN.source,
-            });
+        const match = content.trim().match(this.EXPRESSION_PATTERN);
+        if (!match?.[1]?.trim()) {
             throw new object_expression_error_1.ObjectExpressionError('Invalid expression format', 'INVALID_FORMAT');
         }
-        const expression = match[1].trim();
-        if (!expression) {
-            this.logger.debug('Empty expression detected', {
-                originalContent: trimmed,
-            });
-            throw new object_expression_error_1.ObjectExpressionError('Empty expression not allowed', 'EMPTY_EXPRESSION');
-        }
-        return expression;
+        return match[1].trim();
     }
-    validateExpression(expression, options = {}) {
-        const { maxDepth = this.DEFAULT_MAX_DEPTH, maxLength = this.DEFAULT_MAX_LENGTH, } = options;
-        if (expression.length > maxLength) {
-            this.logger.debug('Expression length exceeded', {
-                expressionLength: expression.length,
-                maxLength,
-                expressionPrefix: expression.substring(0, 50),
-            });
-            throw new object_expression_error_1.ObjectExpressionError(`Expression too long (max: ${maxLength} characters)`, 'EXPRESSION_TOO_LONG');
+    validateExpression(expression) {
+        if (expression.length > this.MAX_EXPRESSION_LENGTH) {
+            throw new object_expression_error_1.ObjectExpressionError(`Expression too long (max: ${this.MAX_EXPRESSION_LENGTH} characters)`, 'EXPRESSION_TOO_LONG');
         }
-        if (this.isFunctionCall(expression)) {
-            this.validateFunctionCall(expression);
+        const segments = expression.split('.').filter(s => s.length > 0);
+        if (segments.length > this.MAX_DEPTH) {
+            throw new object_expression_error_1.ObjectExpressionError(`Expression depth too high (max: ${this.MAX_DEPTH} levels)`, 'DEPTH_EXCEEDED');
         }
-        else {
-            const segments = this.parseExpressionSegments(expression);
-            if (segments.length > maxDepth) {
-                this.logger.debug('Expression depth exceeded', {
-                    segmentCount: segments.length,
-                    maxDepth,
-                    segments: segments.slice(0, 5),
-                });
-                throw new object_expression_error_1.ObjectExpressionError(`Expression depth too high (max: ${maxDepth} levels)`, 'DEPTH_EXCEEDED');
+        for (const segment of segments) {
+            const cleanSegment = segment.replace(/\[\d+\]$/, '');
+            if (this.FORBIDDEN_PROPERTIES.has(cleanSegment)) {
+                throw new object_expression_error_1.ObjectExpressionError('Expression contains forbidden property access', 'FORBIDDEN_PROPERTY');
             }
-            this.validateSegmentsSecurity(segments);
         }
     }
-    evaluateExpression(expression, variables) {
-        const resourceMonitor = {
-            iterations: 0,
-            startTime: Date.now(),
-            memoryBaseline: process.memoryUsage().heapUsed,
-            operationMemory: 0,
-        };
-        this.checkResourceLimits(resourceMonitor);
+    evaluateExpression(expression, ctx) {
         try {
-            if (this.isFunctionCall(expression)) {
-                return this.evaluateFunctionCall(expression, variables, resourceMonitor);
+            const value = (0, lodash_1.get)(ctx, expression);
+            if (typeof value === 'function') {
+                return value.call(ctx);
             }
-            return (0, lodash_1.get)(variables, expression);
+            return value;
         }
         catch (error) {
-            this.logger.debug('Expression evaluation failed', {
-                expression: expression.substring(0, 100),
-                errorMessage: error.message,
-                iterations: resourceMonitor.iterations,
-                timeElapsed: Date.now() - resourceMonitor.startTime,
-            });
             throw new object_expression_error_1.ObjectExpressionError('Failed to evaluate expression', 'EVALUATION_FAILED');
         }
     }
-    evaluateFunctionCall(expression, variables, resourceMonitor) {
-        const functionCall = this.parseFunctionCall(expression);
-        const func = this.functions.get(functionCall.name);
-        const resolvedArgs = functionCall.args.map((arg) => {
-            if (this.isPropertyAccess(arg)) {
-                this.checkResourceLimits(resourceMonitor);
-                return (0, lodash_1.get)(variables, arg);
-            }
-            else {
-                return this.parseLiteral(arg);
-            }
-        });
-        this.checkResourceLimits(resourceMonitor);
-        return this.wrapFunctionWithLimits(func, resourceMonitor)(resolvedArgs, variables);
-    }
-    parseLiteral(arg) {
-        if ((arg.startsWith('"') && arg.endsWith('"')) ||
-            (arg.startsWith("'") && arg.endsWith("'"))) {
-            return arg.slice(1, -1);
-        }
-        return arg;
-    }
-    wrapFunctionWithLimits(func, resourceMonitor) {
-        return (args, variables) => {
-            if (func.minArgs !== undefined && args.length < func.minArgs) {
-                this.logger.debug('Function argument count insufficient', {
-                    functionName: func.name,
-                    providedArgs: args.length,
-                    minArgs: func.minArgs,
-                });
-                throw new object_expression_error_1.ObjectExpressionError(`Function ${func.name} requires at least ${func.minArgs} arguments`, 'INSUFFICIENT_ARGS');
-            }
-            if (func.maxArgs !== undefined && args.length > func.maxArgs) {
-                this.logger.debug('Function argument count exceeded', {
-                    functionName: func.name,
-                    providedArgs: args.length,
-                    maxArgs: func.maxArgs,
-                });
-                throw new object_expression_error_1.ObjectExpressionError(`Function ${func.name} accepts at most ${func.maxArgs} arguments`, 'TOO_MANY_ARGS');
-            }
-            return func.handler(args, variables);
-        };
-    }
-    checkResourceLimits(resourceMonitor) {
-        const currentTime = Date.now();
-        const timeElapsed = currentTime - resourceMonitor.startTime;
-        if (timeElapsed > this.RESOURCE_LIMITS.timeoutMs) {
-            this.logger.debug('Resource timeout exceeded', {
-                timeElapsed,
-                timeoutMs: this.RESOURCE_LIMITS.timeoutMs,
-                iterations: resourceMonitor.iterations,
-            });
-            throw new object_expression_error_1.ObjectExpressionError('Resource timeout exceeded', 'TIMEOUT_EXCEEDED');
-        }
-        resourceMonitor.iterations++;
-        if (resourceMonitor.iterations > this.RESOURCE_LIMITS.maxIterations) {
-            this.logger.debug('Iteration limit exceeded', {
-                iterations: resourceMonitor.iterations,
-                maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                timeElapsed,
-            });
-            throw new object_expression_error_1.ObjectExpressionError('Iteration limit exceeded', 'ITERATION_LIMIT_EXCEEDED');
-        }
-        const currentMemory = process.memoryUsage().heapUsed;
-        const memoryDiff = (currentMemory - resourceMonitor.memoryBaseline) / 1024 / 1024;
-        if (memoryDiff > this.RESOURCE_LIMITS.maxMemoryMB) {
-            this.logger.debug('Memory limit exceeded', {
-                memoryDiff: memoryDiff.toFixed(2),
-                maxMemoryMB: this.RESOURCE_LIMITS.maxMemoryMB,
-                iterations: resourceMonitor.iterations,
-                timeElapsed,
-            });
-            throw new object_expression_error_1.ObjectExpressionError('Memory limit exceeded', 'MEMORY_LIMIT_EXCEEDED');
-        }
-    }
-    isFunctionCall(expression) {
-        const maxLength = 1000;
-        if (expression.length > maxLength) {
-            return false;
-        }
-        return this.FUNCTION_PATTERN.test(expression);
-    }
-    validateFunctionCall(expression) {
-        const functionCall = this.parseFunctionCall(expression);
-        if (!this.functions.has(functionCall.name)) {
-            this.logger.debug('Unknown function called', {
-                functionName: functionCall.name,
-                availableFunctions: Array.from(this.functions.keys()),
-            });
-            throw new object_expression_error_1.ObjectExpressionError(`Unknown function: ${functionCall.name}`, 'UNKNOWN_FUNCTION');
-        }
-        const func = this.functions.get(functionCall.name);
-        if (func.minArgs !== undefined && functionCall.args.length < func.minArgs) {
-            this.logger.debug('Function validation failed - insufficient arguments', {
-                functionName: functionCall.name,
-                providedArgs: functionCall.args.length,
-                minArgs: func.minArgs,
-                args: functionCall.args,
-            });
-            throw new object_expression_error_1.ObjectExpressionError(`Function ${functionCall.name} requires at least ${func.minArgs} arguments`, 'INSUFFICIENT_ARGS');
-        }
-        if (func.maxArgs !== undefined && functionCall.args.length > func.maxArgs) {
-            this.logger.debug('Function validation failed - too many arguments', {
-                functionName: functionCall.name,
-                providedArgs: functionCall.args.length,
-                maxArgs: func.maxArgs,
-                args: functionCall.args,
-            });
-            throw new object_expression_error_1.ObjectExpressionError(`Function ${functionCall.name} accepts at most ${func.maxArgs} arguments`, 'TOO_MANY_ARGS');
-        }
-        for (const arg of functionCall.args) {
-            if (this.isPropertyAccess(arg)) {
-                const segments = this.parseExpressionSegments(arg);
-                this.validateSegmentsSecurity(segments);
-            }
-        }
-    }
-    parseFunctionCall(expression) {
-        const match = expression.match(this.FUNCTION_PATTERN);
-        if (!match) {
-            this.logger.debug('Function call parsing failed', {
-                expression: expression.substring(0, 100),
-                patternUsed: this.FUNCTION_PATTERN.source,
-            });
-            throw new object_expression_error_1.ObjectExpressionError('Invalid function call format', 'INVALID_FUNCTION_FORMAT');
-        }
-        const name = match[1];
-        const argsString = match[2];
-        const args = argsString
-            ? argsString
-                .split(',')
-                .map((arg) => arg.trim())
-                .filter((arg) => arg)
-            : [];
-        return { name, args };
-    }
-    isPropertyAccess(arg) {
-        return /^[a-zA-Z_][a-zA-Z0-9_.-]*$/.test(arg);
-    }
-    parseExpressionSegments(expression) {
-        return expression.split('.').filter((segment) => segment.length > 0);
-    }
-    validateSegmentsSecurity(segments) {
-        for (const segment of segments) {
-            if (this.FORBIDDEN_PROPERTIES.has(segment)) {
-                this.logger.debug('Forbidden property access attempt', {
-                    segment,
-                    allSegments: segments,
-                    forbiddenProperties: Array.from(this.FORBIDDEN_PROPERTIES),
-                });
-                throw new object_expression_error_1.ObjectExpressionError('Expression contains forbidden property access', 'FORBIDDEN_PROPERTY');
-            }
-            if (!this.VALID_SEGMENT_PATTERN.test(segment)) {
-                this.logger.debug('Invalid segment detected', {
-                    segment,
-                    allSegments: segments,
-                    patternUsed: this.VALID_SEGMENT_PATTERN.source,
-                });
-                throw new object_expression_error_1.ObjectExpressionError('Expression contains invalid characters or format', 'INVALID_SEGMENT');
-            }
-        }
-    }
-    registerBuiltInFunctions() {
-        this.registerFunction({
-            name: 'concat',
-            handler: (args) => {
-                return args.reduce((result, arg) => {
-                    if (typeof arg === 'string') {
-                        return result + arg;
-                    }
-                    this.logger.debug('concat function type error', {
-                        argType: typeof arg,
-                        argValue: String(arg).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('concat() function only accepts strings', 'INVALID_ARGUMENT_TYPE');
-                }, '');
-            },
-            minArgs: 2,
-        });
-        this.registerFunction({
-            name: 'map',
-            handler: (args) => {
-                const array = args[0];
-                const propertyPath = args[1];
-                return (0, lodash_1.map)(array, propertyPath);
-            },
-            minArgs: 2,
-        });
-        this.registerFunction({
-            name: 'difference',
-            handler: (args) => {
-                return (0, lodash_1.difference)(args[0], args[1]);
-            },
-            minArgs: 2,
-        });
-        this.registerFunction({
-            name: 'or',
-            handler: (args) => {
-                return !!args[0] || !!args[1];
-            },
-            minArgs: 2,
-        });
-        this.registerFunction({
-            name: 'flatMap',
-            handler: (args, variables) => {
-                const array = args[0];
-                const propertyPath = args[1];
-                if (!Array.isArray(array)) {
-                    this.logger.debug('flatMap function type error - not array', {
-                        argType: typeof array,
-                        argValue: String(array).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('flatMap() function first argument must be an array', 'INVALID_ARGUMENT_TYPE');
-                }
-                if (typeof propertyPath !== 'string') {
-                    this.logger.debug('flatMap function type error - property path not string', {
-                        propertyPathType: typeof propertyPath,
-                        propertyPath: String(propertyPath),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('flatMap() function second argument must be a property path string', 'INVALID_ARGUMENT_TYPE');
-                }
-                if (array.length > this.RESOURCE_LIMITS.maxIterations) {
-                    this.logger.debug('flatMap array too large', {
-                        arrayLength: array.length,
-                        maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError(`Array too large for flatMap (max: ${this.RESOURCE_LIMITS.maxIterations})`, 'ARRAY_TOO_LARGE');
-                }
-                const result = [];
-                let iterations = 0;
-                for (const item of array) {
-                    if (++iterations > this.RESOURCE_LIMITS.maxIterations) {
-                        this.logger.debug('flatMap iteration limit exceeded', {
-                            iterations,
-                            maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                            resultLength: result.length,
-                        });
-                        throw new object_expression_error_1.ObjectExpressionError('Iteration limit exceeded in flatMap', 'ITERATION_LIMIT_EXCEEDED');
-                    }
-                    if (typeof item === 'object' && item !== null) {
-                        const value = (0, lodash_1.get)(item, propertyPath);
-                        if (Array.isArray(value)) {
-                            for (const valueItem of value) {
-                                if (result.length >= this.RESOURCE_LIMITS.maxIterations) {
-                                    this.logger.debug('flatMap result too large', {
-                                        resultLength: result.length,
-                                        maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                                    });
-                                    throw new object_expression_error_1.ObjectExpressionError('Result array too large in flatMap', 'RESULT_TOO_LARGE');
-                                }
-                                result.push(valueItem);
-                            }
-                        }
-                        else if (value !== undefined) {
-                            if (result.length >= this.RESOURCE_LIMITS.maxIterations) {
-                                this.logger.debug('flatMap result too large', {
-                                    resultLength: result.length,
-                                    maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                                });
-                                throw new object_expression_error_1.ObjectExpressionError('Result array too large in flatMap', 'RESULT_TOO_LARGE');
-                            }
-                            result.push(value);
-                        }
-                    }
-                }
-                return result;
-            },
-            minArgs: 2,
-            maxArgs: 2,
-        });
-        this.registerFunction({
-            name: 'length',
-            handler: (args) => {
-                const value = args[0];
-                if (Array.isArray(value) || typeof value === 'string') {
-                    return value.length;
-                }
-                this.logger.debug('length function type error', {
-                    argType: typeof value,
-                    isArray: Array.isArray(value),
-                    argValue: String(value).substring(0, 50),
-                });
-                throw new object_expression_error_1.ObjectExpressionError('length() function only accepts arrays or strings', 'INVALID_ARGUMENT_TYPE');
-            },
-            minArgs: 1,
-            maxArgs: 1,
-        });
-        this.registerFunction({
-            name: 'first',
-            handler: (args) => {
-                const array = args[0];
-                if (!Array.isArray(array)) {
-                    this.logger.debug('first function type error', {
-                        argType: typeof array,
-                        argValue: String(array).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('first() function only accepts arrays', 'INVALID_ARGUMENT_TYPE');
-                }
-                return array[0];
-            },
-            minArgs: 1,
-            maxArgs: 1,
-        });
-        this.registerFunction({
-            name: 'last',
-            handler: (args) => {
-                const array = args[0];
-                if (!Array.isArray(array)) {
-                    this.logger.debug('last function type error', {
-                        argType: typeof array,
-                        argValue: String(array).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('last() function only accepts arrays', 'INVALID_ARGUMENT_TYPE');
-                }
-                return array[array.length - 1];
-            },
-            minArgs: 1,
-            maxArgs: 1,
-        });
-        this.registerFunction({
-            name: 'merge',
-            handler: (args) => {
-                const obj1 = args[0];
-                const obj2 = args[1];
-                if (typeof obj1 !== 'object' || obj1 === null || Array.isArray(obj1)) {
-                    this.logger.debug('merge function type error - first arg not object', {
-                        argType: typeof obj1,
-                        argValue: String(obj1).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('merge() function first argument must be an object', 'INVALID_ARGUMENT_TYPE');
-                }
-                if (typeof obj2 !== 'object' || obj2 === null || Array.isArray(obj2)) {
-                    this.logger.debug('merge function type error - second arg not object', {
-                        argType: typeof obj2,
-                        argValue: String(obj2).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('merge() function second argument must be an object', 'INVALID_ARGUMENT_TYPE');
-                }
-                const combinedKeys = new Set([
-                    ...Object.keys(obj1),
-                    ...Object.keys(obj2),
-                ]);
-                if (combinedKeys.size > this.RESOURCE_LIMITS.maxIterations) {
-                    this.logger.debug('merge result too large', {
-                        combinedKeyCount: combinedKeys.size,
-                        maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError(`Merged object too large (max keys: ${this.RESOURCE_LIMITS.maxIterations})`, 'OBJECT_TOO_LARGE');
-                }
-                return { ...obj1, ...obj2 };
-            },
-            minArgs: 2,
-            maxArgs: 2,
-        });
-        this.registerFunction({
-            name: 'mergeWith',
-            handler: (args) => {
-                const array = args[0];
-                const commonObject = args[1];
-                if (!Array.isArray(array)) {
-                    this.logger.debug('mergeWith function type error - not array', {
-                        argType: typeof array,
-                        argValue: String(array).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('mergeWith() function first argument must be an array', 'INVALID_ARGUMENT_TYPE');
-                }
-                if (typeof commonObject !== 'object' ||
-                    commonObject === null ||
-                    Array.isArray(commonObject)) {
-                    this.logger.debug('mergeWith function type error - common object not object', {
-                        argType: typeof commonObject,
-                        argValue: String(commonObject).substring(0, 50),
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError('mergeWith() function second argument must be an object', 'INVALID_ARGUMENT_TYPE');
-                }
-                if (array.length > this.RESOURCE_LIMITS.maxIterations) {
-                    this.logger.debug('mergeWith array too large', {
-                        arrayLength: array.length,
-                        maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                    });
-                    throw new object_expression_error_1.ObjectExpressionError(`Array too large for mergeWith (max: ${this.RESOURCE_LIMITS.maxIterations})`, 'ARRAY_TOO_LARGE');
-                }
-                const result = [];
-                let iterations = 0;
-                for (const item of array) {
-                    if (++iterations > this.RESOURCE_LIMITS.maxIterations) {
-                        this.logger.debug('mergeWith iteration limit exceeded', {
-                            iterations,
-                            maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                        });
-                        throw new object_expression_error_1.ObjectExpressionError('Iteration limit exceeded in mergeWith', 'ITERATION_LIMIT_EXCEEDED');
-                    }
-                    if (typeof item === 'object' &&
-                        item !== null &&
-                        !Array.isArray(item)) {
-                        const combinedKeys = new Set([
-                            ...Object.keys(item),
-                            ...Object.keys(commonObject),
-                        ]);
-                        if (combinedKeys.size > this.RESOURCE_LIMITS.maxIterations) {
-                            this.logger.debug('mergeWith merged item too large', {
-                                combinedKeyCount: combinedKeys.size,
-                                maxIterations: this.RESOURCE_LIMITS.maxIterations,
-                                itemIndex: iterations - 1,
-                            });
-                            throw new object_expression_error_1.ObjectExpressionError('Merged item too large in mergeWith', 'OBJECT_TOO_LARGE');
-                        }
-                        result.push({ ...item, ...commonObject });
-                    }
-                    else {
-                        this.logger.debug('mergeWith skipping non-object item', {
-                            itemType: typeof item,
-                            itemValue: String(item).substring(0, 50),
-                            itemIndex: iterations - 1,
-                        });
-                        result.push(item);
-                    }
-                }
-                return result;
-            },
-            minArgs: 2,
-            maxArgs: 2,
-        });
-    }
-    registerFunction(func) {
-        this.functions.set(func.name, func);
-    }
 };
 exports.ObjectExpressionHandler = ObjectExpressionHandler;
 exports.ObjectExpressionHandler = ObjectExpressionHandler = ObjectExpressionHandler_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
+    (0, common_1.Injectable)()
 ], ObjectExpressionHandler);
 //# sourceMappingURL=object-expression.handler.js.map