@memberjunction/react-linter 0.0.1 → 5.38.0

package/dist/type-inference-engine.js

@@ -0,0 +1,1151 @@
+/**
+ * Type Inference Engine - AST-based type inference for component linting
+ *
+ * This module analyzes JavaScript AST to infer and track types throughout
+ * component code. It integrates with TypeContext to provide comprehensive
+ * type information for validation rules.
+ */
+import _traverse from '@babel/traverse';
+import * as t from '@babel/types';
+const traverse = ((_traverse.default) ?? _traverse);
+import { TypeContext, StandardTypes, mapSQLTypeToJSType, areTypesCompatible } from './type-context.js';
+/**
+ * TypeInferenceEngine - Analyzes AST to infer and track types
+ */
+export class TypeInferenceEngine {
+    constructor(componentSpec, contextUser) {
+        this.errors = [];
+        this.functionReturnTypes = new Map();
+        /** Maps setState setter names to their corresponding state variable names */
+        this.stateSetterMap = new Map();
+        this.componentSpec = componentSpec;
+        this.contextUser = contextUser;
+        this.typeContext = new TypeContext(componentSpec);
+    }
+    /**
+     * Analyze an AST and build type context
+     */
+    async analyze(ast) {
+        this.errors = [];
+        // First pass: collect all variable declarations and their types
+        await this.collectVariableTypes(ast);
+        // Return the result
+        return {
+            typeContext: this.typeContext,
+            errors: this.errors
+        };
+    }
+    /**
+     * Get the type context after analysis
+     */
+    getTypeContext() {
+        return this.typeContext;
+    }
+    /**
+     * Get type inference errors found during analysis
+     */
+    getErrors() {
+        return this.errors;
+    }
+    /**
+     * First pass: collect variable types from declarations and assignments
+     */
+    async collectVariableTypes(ast) {
+        const self = this;
+        let functionCounter = 0; // Counter for anonymous functions
+        traverse(ast, {
+            // Track variable declarations
+            VariableDeclarator(path) {
+                self.inferDeclaratorType(path);
+                // Also check if it's a function expression assignment
+                // const calculateMetrics = () => { return {...} }
+                const node = path.node;
+                if (t.isIdentifier(node.id) &&
+                    (t.isArrowFunctionExpression(node.init) || t.isFunctionExpression(node.init))) {
+                    self.trackFunctionReturnType(node.id.name, node.init);
+                }
+            },
+            // Track assignments to existing variables
+            AssignmentExpression(path) {
+                self.inferAssignmentType(path);
+            },
+            // Track setState calls to update state variable types
+            CallExpression(path) {
+                if (t.isIdentifier(path.node.callee)) {
+                    const setterName = path.node.callee.name;
+                    const stateVarName = self.stateSetterMap.get(setterName);
+                    if (stateVarName && path.node.arguments.length > 0) {
+                        const argType = self.inferExpressionType(path.node.arguments[0], path);
+                        // Only update if we inferred a meaningful type (not unknown)
+                        if (argType.type !== 'unknown') {
+                            self.typeContext.setVariableType(stateVarName, argType);
+                        }
+                    }
+                }
+            },
+            // Track function parameters and return types with scoping
+            FunctionDeclaration: {
+                enter(path) {
+                    const functionName = path.node.id?.name || `anon_func_${functionCounter++}`;
+                    self.typeContext.enterScope(functionName);
+                    self.inferFunctionParameterTypes(path);
+                    // Track return type of named functions
+                    if (path.node.id) {
+                        self.trackFunctionReturnType(path.node.id.name, path.node);
+                    }
+                },
+                exit(path) {
+                    self.typeContext.exitScope();
+                }
+            },
+            // Track arrow function scoping
+            ArrowFunctionExpression: {
+                enter(path) {
+                    // Find the function name from parent if it's a variable declarator
+                    let functionName = `anon_arrow_${functionCounter++}`;
+                    const parent = path.parent;
+                    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+                        functionName = parent.id.name;
+                    }
+                    self.typeContext.enterScope(functionName);
+                    // Try to infer callback parameter types from array method context first
+                    const inferredFromCallback = self.inferCallbackParameterTypes(path);
+                    if (!inferredFromCallback) {
+                        self.inferArrowFunctionParameterTypes(path);
+                    }
+                },
+                exit(path) {
+                    self.typeContext.exitScope();
+                }
+            },
+            // Track function expression scoping
+            FunctionExpression: {
+                enter(path) {
+                    const functionName = path.node.id?.name || `anon_func_expr_${functionCounter++}`;
+                    self.typeContext.enterScope(functionName);
+                },
+                exit(path) {
+                    self.typeContext.exitScope();
+                }
+            }
+        });
+    }
+    /**
+     * Infer type from a variable declarator
+     */
+    inferDeclaratorType(path) {
+        const node = path.node;
+        // Get variable name(s)
+        if (t.isIdentifier(node.id)) {
+            const varName = node.id.name;
+            if (node.init) {
+                const type = this.inferExpressionType(node.init, path);
+                this.typeContext.setVariableType(varName, type);
+            }
+            else {
+                // Declared but not initialized
+                this.typeContext.setVariableType(varName, { type: 'undefined', nullable: true });
+            }
+        }
+        else if (t.isObjectPattern(node.id) && node.init) {
+            // Destructuring: const { a, b } = obj
+            this.inferDestructuringTypes(node.id, node.init, path);
+        }
+        else if (t.isArrayPattern(node.id) && node.init) {
+            // Array destructuring: const [a, b] = arr
+            this.inferArrayDestructuringTypes(node.id, node.init, path);
+        }
+    }
+    /**
+     * Infer type from an assignment expression
+     */
+    inferAssignmentType(path) {
+        const node = path.node;
+        if (t.isIdentifier(node.left)) {
+            const varName = node.left.name;
+            const type = this.inferExpressionType(node.right, path);
+            this.typeContext.setVariableType(varName, type);
+        }
+    }
+    /**
+     * Infer types for function parameters (component props)
+     */
+    inferFunctionParameterTypes(path) {
+        const params = path.node.params;
+        for (const param of params) {
+            if (t.isIdentifier(param)) {
+                // Simple parameter - unknown type
+                this.typeContext.setVariableType(param.name, StandardTypes.unknown);
+            }
+            else if (t.isObjectPattern(param)) {
+                // Destructured props - this is the common component pattern
+                this.inferComponentPropsTypes(param);
+            }
+        }
+    }
+    /**
+     * Infer callback parameter types from array method context.
+     * When an arrow function is a callback to .map(), .filter(), .reduce(), etc.,
+     * the first parameter inherits the array's element type.
+     *
+     * Example: results.map(m => m.Salary)
+     *   → `results` is array of entity-row(Members) → `m` is entity-row(Members)
+     *
+     * Returns true if callback parameters were inferred, false if not applicable.
+     */
+    inferCallbackParameterTypes(path) {
+        const parent = path.parent;
+        // Check if this arrow function is the first argument to a method call
+        // Pattern: someArray.method(callback) or someArray?.method(callback)
+        if (!t.isCallExpression(parent) && !t.isOptionalCallExpression(parent))
+            return false;
+        if (parent.arguments[0] !== path.node && parent.arguments[1] !== path.node)
+            return false;
+        const callee = parent.callee;
+        if ((!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) || !t.isIdentifier(callee.property))
+            return false;
+        const methodName = callee.property.name;
+        const arrayIterMethods = ['map', 'filter', 'forEach', 'find', 'some', 'every', 'flatMap', 'sort'];
+        const isReduce = methodName === 'reduce';
+        if (!arrayIterMethods.includes(methodName) && !isReduce)
+            return false;
+        // Infer the type of the array being iterated
+        const arrayType = this.inferExpressionType(callee.object, path.parentPath ?? undefined);
+        if (arrayType.type !== 'array' || !arrayType.arrayElementType)
+            return false;
+        const elementType = arrayType.arrayElementType;
+        const params = path.node.params;
+        if (isReduce) {
+            // reduce((accumulator, currentValue, index, array) => ...)
+            // First param is accumulator (unknown type), second param is the element
+            if (params.length >= 1 && t.isIdentifier(params[0])) {
+                this.typeContext.setVariableType(params[0].name, StandardTypes.unknown);
+            }
+            if (params.length >= 2 && t.isIdentifier(params[1])) {
+                this.typeContext.setVariableType(params[1].name, elementType);
+            }
+        }
+        else if (methodName === 'sort') {
+            // sort((a, b) => ...) — both params are elements
+            if (params.length >= 1 && t.isIdentifier(params[0])) {
+                this.typeContext.setVariableType(params[0].name, elementType);
+            }
+            if (params.length >= 2 && t.isIdentifier(params[1])) {
+                this.typeContext.setVariableType(params[1].name, elementType);
+            }
+        }
+        else {
+            // map/filter/forEach/find/some/every/flatMap: (element, index, array) => ...
+            if (params.length >= 1 && t.isIdentifier(params[0])) {
+                this.typeContext.setVariableType(params[0].name, elementType);
+            }
+            if (params.length >= 2 && t.isIdentifier(params[1])) {
+                this.typeContext.setVariableType(params[1].name, StandardTypes.number); // index
+            }
+        }
+        // Handle remaining params as unknown
+        for (let i = 2; i < params.length; i++) {
+            const param = params[i];
+            if (t.isIdentifier(param)) {
+                this.typeContext.setVariableType(param.name, StandardTypes.unknown);
+            }
+        }
+        return true;
+    }
+    /**
+     * Infer types for arrow function parameters
+     */
+    inferArrowFunctionParameterTypes(path) {
+        const params = path.node.params;
+        for (const param of params) {
+            if (t.isIdentifier(param)) {
+                this.typeContext.setVariableType(param.name, StandardTypes.unknown);
+            }
+            else if (t.isObjectPattern(param)) {
+                this.inferComponentPropsTypes(param);
+            }
+        }
+    }
+    /**
+     * Infer types for component props from destructuring pattern
+     */
+    inferComponentPropsTypes(pattern) {
+        for (const prop of pattern.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                // Known standard props
+                switch (propName) {
+                    case 'utilities':
+                        this.typeContext.setVariableType(propName, {
+                            type: 'object',
+                            fields: new Map([
+                                ['rv', { type: 'object', fromMetadata: true }], // RunView service
+                                ['rq', { type: 'object', fromMetadata: true }], // RunQuery service
+                                ['md', { type: 'object', fromMetadata: true }] // Metadata
+                            ])
+                        });
+                        break;
+                    case 'styles':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'components':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'callbacks':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'savedUserSettings':
+                        this.typeContext.setVariableType(propName, { type: 'object', nullable: true });
+                        break;
+                    case 'onSavedUserSettingsChange':
+                    case 'onSaveUserSettings':
+                        this.typeContext.setVariableType(propName, { type: 'function' });
+                        break;
+                    default:
+                        // Check if it's a prop defined in the component spec
+                        if (this.componentSpec?.properties) {
+                            const specProp = this.componentSpec.properties.find(p => p.name === propName);
+                            if (specProp) {
+                                this.typeContext.setVariableType(propName, {
+                                    type: this.mapSpecTypeToJSType(specProp.type),
+                                    nullable: !specProp.required
+                                });
+                                break;
+                            }
+                        }
+                        // Check if it's an event (on* prefix)
+                        if (propName.startsWith('on')) {
+                            this.typeContext.setVariableType(propName, { type: 'function', nullable: true });
+                        }
+                        else {
+                            this.typeContext.setVariableType(propName, StandardTypes.unknown);
+                        }
+                }
+            }
+        }
+    }
+    /**
+     * Track function return type by analyzing its body
+     */
+    trackFunctionReturnType(functionName, func) {
+        const body = func.body;
+        // Arrow function with expression body: () => ({...})
+        if (t.isExpression(body)) {
+            const returnType = this.inferExpressionType(body);
+            this.functionReturnTypes.set(functionName, returnType);
+            return;
+        }
+        // Function with block body - find return statements
+        if (t.isBlockStatement(body)) {
+            // Try to analyze the function body for object building patterns
+            const returnType = this.analyzeObjectBuildingPattern(body);
+            if (returnType) {
+                this.functionReturnTypes.set(functionName, returnType);
+                return;
+            }
+            // Fallback: Find the first return statement
+            for (const stmt of body.body) {
+                if (t.isReturnStatement(stmt) && stmt.argument) {
+                    const inferredType = this.inferExpressionType(stmt.argument);
+                    this.functionReturnTypes.set(functionName, inferredType);
+                    return;
+                }
+            }
+        }
+        // No return statement found or void function
+        this.functionReturnTypes.set(functionName, StandardTypes.unknown);
+    }
+    /**
+     * Analyze common object-building patterns in function bodies
+     * Pattern: const obj = {}; forEach(...) { obj[key] = { prop: value } }; return obj;
+     */
+    analyzeObjectBuildingPattern(body) {
+        let objectVarName = null;
+        let objectElementType = null;
+        const debugEnabled = false;
+        // Look for: const obj = {}; ... obj[key] = { ... }; ... return obj;
+        for (const stmt of body.body) {
+            // Find variable declaration: const obj = {};
+            if (t.isVariableDeclaration(stmt)) {
+                for (const decl of stmt.declarations) {
+                    if (t.isIdentifier(decl.id) && t.isObjectExpression(decl.init) && decl.init.properties.length === 0) {
+                        objectVarName = decl.id.name;
+                        if (debugEnabled)
+                            console.log('[TypeInference] Found empty object declaration:', objectVarName);
+                    }
+                }
+            }
+            // Look for forEach or for loops that populate the object
+            if (objectVarName && t.isExpressionStatement(stmt) && t.isCallExpression(stmt.expression)) {
+                const call = stmt.expression;
+                if (t.isMemberExpression(call.callee) &&
+                    t.isIdentifier(call.callee.property) &&
+                    call.callee.property.name === 'forEach' &&
+                    call.arguments.length > 0) {
+                    const callback = call.arguments[0];
+                    if ((t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) &&
+                        t.isBlockStatement(callback.body)) {
+                        // Look for obj[something] = { ... } pattern inside forEach
+                        for (const innerStmt of callback.body.body) {
+                            if (t.isExpressionStatement(innerStmt) &&
+                                t.isAssignmentExpression(innerStmt.expression) &&
+                                innerStmt.expression.operator === '=') {
+                                const left = innerStmt.expression.left;
+                                const right = innerStmt.expression.right;
+                                // Check if left is obj[...] and right is object literal
+                                if (t.isMemberExpression(left) &&
+                                    left.computed &&
+                                    t.isIdentifier(left.object) &&
+                                    left.object.name === objectVarName &&
+                                    t.isObjectExpression(right)) {
+                                    // Infer the type of the object literal
+                                    objectElementType = this.inferObjectType(right);
+                                    if (debugEnabled)
+                                        console.log('[TypeInference] Found object literal assignment, inferred type:', objectElementType);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Check if this function returns the object
+            if (objectVarName && objectElementType && t.isReturnStatement(stmt)) {
+                if (t.isIdentifier(stmt.argument) && stmt.argument.name === objectVarName) {
+                    // Function returns an object whose values are of the element type
+                    const result = {
+                        type: 'object',
+                        fields: new Map(), // Dictionary, not structured object
+                        objectValueType: objectElementType
+                    };
+                    if (debugEnabled)
+                        console.log('[TypeInference] Returning object building pattern type:', result);
+                    return result;
+                }
+            }
+        }
+        if (debugEnabled && objectVarName && objectElementType) {
+            console.log('[TypeInference] Had object and element type but no return statement matched');
+        }
+        return null;
+    }
+    /**
+     * Map component spec type to JavaScript type
+     */
+    mapSpecTypeToJSType(specType) {
+        if (!specType)
+            return 'unknown';
+        const type = specType.toLowerCase();
+        if (type === 'string')
+            return 'string';
+        if (type === 'number' || type === 'int' || type === 'integer' || type === 'float' || type === 'decimal')
+            return 'number';
+        if (type === 'boolean' || type === 'bool')
+            return 'boolean';
+        if (type.startsWith('array') || type.endsWith('[]'))
+            return 'array';
+        if (type === 'object')
+            return 'object';
+        if (type === 'function')
+            return 'function';
+        return 'unknown';
+    }
+    /**
+     * Infer types from object destructuring
+     */
+    inferDestructuringTypes(pattern, init, path) {
+        const sourceType = this.inferExpressionType(init, path);
+        for (const prop of pattern.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                const varName = t.isIdentifier(prop.value) ? prop.value.name : propName;
+                // Try to get the property type from the source
+                if (sourceType.fields?.has(propName)) {
+                    const fieldType = sourceType.fields.get(propName);
+                    this.typeContext.setVariableType(varName, { type: fieldType.type, nullable: fieldType.nullable });
+                }
+                else {
+                    this.typeContext.setVariableType(varName, StandardTypes.unknown);
+                }
+            }
+            else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                // Rest element: const { a, ...rest } = obj
+                this.typeContext.setVariableType(prop.argument.name, { type: 'object' });
+            }
+        }
+    }
+    /**
+     * Infer types from array destructuring
+     */
+    inferArrayDestructuringTypes(pattern, init, path) {
+        const sourceType = this.inferExpressionType(init, path);
+        // Detect useState pattern: const [state, setState] = useState(initialValue)
+        const isUseState = t.isCallExpression(init) &&
+            t.isIdentifier(init.callee) && init.callee.name === 'useState';
+        for (let i = 0; i < pattern.elements.length; i++) {
+            const element = pattern.elements[i];
+            if (t.isIdentifier(element)) {
+                if (isUseState && i === 1) {
+                    // Second element is the setter function — register the state/setter pair
+                    this.typeContext.setVariableType(element.name, StandardTypes.function);
+                    const stateVar = pattern.elements[0];
+                    if (t.isIdentifier(stateVar)) {
+                        this.stateSetterMap.set(element.name, stateVar.name);
+                    }
+                }
+                else if (sourceType.arrayElementType) {
+                    this.typeContext.setVariableType(element.name, sourceType.arrayElementType);
+                }
+                else {
+                    this.typeContext.setVariableType(element.name, StandardTypes.unknown);
+                }
+            }
+            else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
+                // Rest element: const [a, ...rest] = arr
+                this.typeContext.setVariableType(element.argument.name, {
+                    type: 'array',
+                    arrayElementType: sourceType.arrayElementType
+                });
+            }
+        }
+    }
+    /**
+     * Infer the type of an expression
+     */
+    inferExpressionType(node, path) {
+        // Literals - now track actual values for constant analysis
+        if (t.isStringLiteral(node)) {
+            return { ...StandardTypes.string, literalValue: node.value };
+        }
+        if (t.isTemplateLiteral(node)) {
+            // For template literals, we can't always know the final value
+            return StandardTypes.string;
+        }
+        if (t.isNumericLiteral(node)) {
+            return { ...StandardTypes.number, literalValue: node.value };
+        }
+        if (t.isBooleanLiteral(node)) {
+            return { ...StandardTypes.boolean, literalValue: node.value };
+        }
+        if (t.isNullLiteral(node)) {
+            return { ...StandardTypes.null, literalValue: null };
+        }
+        if (t.isArrayExpression(node)) {
+            return this.inferArrayType(node, path);
+        }
+        if (t.isObjectExpression(node)) {
+            return this.inferObjectType(node, path);
+        }
+        // Identifiers (variable references)
+        if (t.isIdentifier(node)) {
+            return this.typeContext.getVariableType(node.name) || StandardTypes.unknown;
+        }
+        // Function expressions
+        if (t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) {
+            return StandardTypes.function;
+        }
+        // Call expressions (including optional: a?.b())
+        if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+            return this.inferCallExpressionType(node, path);
+        }
+        // New expressions (constructor calls like new Date())
+        if (t.isNewExpression(node)) {
+            return this.inferNewExpressionType(node, path);
+        }
+        // Member expressions (including optional chaining: a?.b, a?.[0])
+        if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+            return this.inferMemberExpressionType(node, path);
+        }
+        // Binary expressions
+        if (t.isBinaryExpression(node)) {
+            return this.inferBinaryExpressionType(node, path);
+        }
+        // Unary expressions
+        if (t.isUnaryExpression(node)) {
+            return this.inferUnaryExpressionType(node);
+        }
+        // Conditional (ternary) expressions
+        if (t.isConditionalExpression(node)) {
+            // Return the type of the consequent (or alternate if different, return unknown)
+            const consequentType = this.inferExpressionType(node.consequent, path);
+            const alternateType = this.inferExpressionType(node.alternate, path);
+            if (areTypesCompatible(consequentType, alternateType)) {
+                return consequentType;
+            }
+            return StandardTypes.unknown;
+        }
+        // Logical expressions (&&, ||, ??)
+        if (t.isLogicalExpression(node)) {
+            // For ||, the result is the first truthy value
+            // For &&, the result is the first falsy or last value
+            // For ??, the result is the first non-nullish value
+            return this.inferExpressionType(node.right, path);
+        }
+        // Await expressions
+        if (t.isAwaitExpression(node)) {
+            return this.inferExpressionType(node.argument, path);
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Infer type for array expressions
+     */
+    inferArrayType(node, path) {
+        if (node.elements.length === 0) {
+            return { type: 'array', arrayElementType: StandardTypes.unknown };
+        }
+        // Try to infer element type from first element
+        const firstElement = node.elements[0];
+        if (firstElement && !t.isSpreadElement(firstElement)) {
+            const elementType = this.inferExpressionType(firstElement, path);
+            return { type: 'array', arrayElementType: elementType };
+        }
+        return { type: 'array', arrayElementType: StandardTypes.unknown };
+    }
+    /**
+     * Infer type for object expressions
+     */
+    inferObjectType(node, path) {
+        const fields = new Map();
+        for (const prop of node.properties) {
+            // Handle spread elements: { ...otherObject, newProp: value }
+            if (t.isSpreadElement(prop)) {
+                const spreadType = this.inferExpressionType(prop.argument, path);
+                // If spreading an object, merge its fields into our fields map
+                if (spreadType.type === 'object' && spreadType.fields) {
+                    for (const [fieldName, fieldInfo] of spreadType.fields.entries()) {
+                        // Only add if not already present (later properties override spread)
+                        if (!fields.has(fieldName)) {
+                            fields.set(fieldName, fieldInfo);
+                        }
+                    }
+                }
+            }
+            // Handle regular object properties
+            else if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                const propType = this.inferExpressionType(prop.value, path);
+                fields.set(propName, {
+                    type: propType.type,
+                    fromMetadata: false,
+                    nullable: propType.nullable
+                });
+            }
+        }
+        return { type: 'object', fields };
+    }
+    /**
+     * Infer type for call expressions
+     */
+    inferCallExpressionType(node, path) {
+        // Check for user-defined function calls
+        if (t.isIdentifier(node.callee)) {
+            const functionName = node.callee.name;
+            // Check if we've tracked this function's return type
+            const returnType = this.functionReturnTypes.get(functionName);
+            if (returnType) {
+                return returnType;
+            }
+            // Check for React hooks that return computed values
+            // useMemo(() => { return {...} }, [deps]) - returns the memoized value
+            if (functionName === 'useMemo' && node.arguments.length > 0) {
+                const callback = node.arguments[0];
+                // Extract the return type from the callback
+                if (t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) {
+                    const body = callback.body;
+                    // Arrow function with expression body: useMemo(() => ({...}))
+                    if (t.isExpression(body)) {
+                        return this.inferExpressionType(body, path);
+                    }
+                    // Arrow function with block body: useMemo(() => { return {...} })
+                    if (t.isBlockStatement(body)) {
+                        // Find return statement
+                        for (const stmt of body.body) {
+                            if (t.isReturnStatement(stmt) && stmt.argument) {
+                                return this.inferExpressionType(stmt.argument, path);
+                            }
+                        }
+                    }
+                }
+            }
+            // useCallback returns a function
+            if (functionName === 'useCallback') {
+                return StandardTypes.function;
+            }
+            // useState(initialValue) — return the type of the initial value so that
+            // array destructuring `const [state, setState] = useState(X)` propagates X's type to `state`
+            if (functionName === 'useState') {
+                if (node.arguments.length > 0) {
+                    const initType = this.inferExpressionType(node.arguments[0], path);
+                    // For null/undefined initializers, use unknown+nullable to avoid false positives
+                    // (the actual type will be set by setState calls later)
+                    if (initType.type === 'null' || initType.type === 'undefined') {
+                        return { type: 'array', arrayElementType: { ...StandardTypes.unknown, nullable: true } };
+                    }
+                    return { type: 'array', arrayElementType: initType };
+                }
+                // useState() with no argument — state is undefined/nullable
+                return { type: 'array', arrayElementType: { ...StandardTypes.unknown, nullable: true } };
+            }
+        }
+        // Check for RunView/RunQuery calls
+        if (t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)) {
+            const calleeObj = node.callee.object;
+            const calleeProp = node.callee.property;
+            // utilities.rv.RunView or utilities.rv.RunViews
+            if ((t.isMemberExpression(calleeObj) || t.isOptionalMemberExpression(calleeObj)) &&
+                t.isIdentifier(calleeObj.property) &&
+                t.isIdentifier(calleeProp)) {
+                const serviceName = calleeObj.property.name;
+                const methodName = calleeProp.name;
+                if (serviceName === 'rv' && (methodName === 'RunView' || methodName === 'RunViews')) {
+                    return this.inferRunViewResultType(node);
+                }
+                if (serviceName === 'rq' && methodName === 'RunQuery') {
+                    return this.inferRunQueryResultType(node);
+                }
+            }
+        }
+        // Object.values() - returns array of object's values
+        if ((t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)) &&
+            t.isIdentifier(node.callee.object) &&
+            node.callee.object.name === 'Object' &&
+            t.isIdentifier(node.callee.property) &&
+            node.callee.property.name === 'values' &&
+            node.arguments.length === 1) {
+            const objectType = this.inferExpressionType(node.arguments[0], path);
+            if (objectType.type === 'object' && objectType.objectValueType) {
+                // Return array of the object's value type
+                return {
+                    type: 'array',
+                    arrayElementType: objectType.objectValueType
+                };
+            }
+            // Fallback: unknown array
+            return { type: 'array', arrayElementType: StandardTypes.unknown };
+        }
+        // Array methods that return arrays
+        if ((t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)) && t.isIdentifier(node.callee.property)) {
+            const methodName = node.callee.property.name;
+            const arrayMethods = ['filter', 'map', 'slice', 'concat', 'flat', 'flatMap', 'sort', 'reverse'];
+            if (arrayMethods.includes(methodName)) {
+                const arrayType = this.inferExpressionType(node.callee.object, path);
+                if (arrayType.type === 'array') {
+                    // For map, the element type might change
+                    if (methodName === 'map') {
+                        return { type: 'array', arrayElementType: StandardTypes.unknown };
+                    }
+                    return arrayType;
+                }
+            }
+            // Array methods that return elements
+            if (methodName === 'find') {
+                const arrayType = this.inferExpressionType(node.callee.object, path);
+                if (arrayType.arrayElementType) {
+                    return { ...arrayType.arrayElementType, nullable: true };
+                }
+            }
+            // Methods that return numbers
+            if (['indexOf', 'findIndex', 'length'].includes(methodName)) {
+                return StandardTypes.number;
+            }
+            // Methods that return booleans
+            if (['includes', 'some', 'every'].includes(methodName)) {
+                return StandardTypes.boolean;
+            }
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Infer type for new expressions (constructor calls)
+     */
+    inferNewExpressionType(node, path) {
+        // Check for common constructors
+        if (t.isIdentifier(node.callee)) {
+            const constructorName = node.callee.name;
+            // Date constructor
+            if (constructorName === 'Date') {
+                return { type: 'Date', fromMetadata: false };
+            }
+            // Array constructor
+            if (constructorName === 'Array') {
+                return { type: 'array', arrayElementType: StandardTypes.unknown };
+            }
+            // Object constructor
+            if (constructorName === 'Object') {
+                return { type: 'object', fields: new Map() };
+            }
+            // Map constructor
+            if (constructorName === 'Map') {
+                return { type: 'Map', fromMetadata: false };
+            }
+            // Set constructor
+            if (constructorName === 'Set') {
+                return { type: 'Set', fromMetadata: false };
+            }
+            // RegExp constructor
+            if (constructorName === 'RegExp') {
+                return { type: 'RegExp', fromMetadata: false };
+            }
+            // Error and related constructors
+            if (['Error', 'TypeError', 'RangeError', 'ReferenceError', 'SyntaxError'].includes(constructorName)) {
+                return { type: 'Error', fromMetadata: false };
+            }
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Infer type for RunView result
+     */
+    inferRunViewResultType(node) {
+        // Try to extract EntityName from the arguments
+        let entityName;
+        if (node.arguments.length > 0 && t.isObjectExpression(node.arguments[0])) {
+            for (const prop of node.arguments[0].properties) {
+                if (t.isObjectProperty(prop) &&
+                    t.isIdentifier(prop.key) &&
+                    prop.key.name === 'EntityName' &&
+                    t.isStringLiteral(prop.value)) {
+                    entityName = prop.value.value;
+                    break;
+                }
+            }
+        }
+        return this.typeContext.createRunViewResultType(entityName || 'unknown');
+    }
+    /**
+     * Infer type for RunQuery result
+     */
+    inferRunQueryResultType(node) {
+        // Try to extract QueryName and Parameters from the arguments
+        let queryName;
+        let parametersNode;
+        if (node.arguments.length > 0 && t.isObjectExpression(node.arguments[0])) {
+            for (const prop of node.arguments[0].properties) {
+                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                    if (prop.key.name === 'QueryName' && t.isStringLiteral(prop.value)) {
+                        queryName = prop.value.value;
+                    }
+                    else if (prop.key.name === 'Parameters' && t.isObjectExpression(prop.value)) {
+                        parametersNode = prop.value;
+                    }
+                }
+            }
+        }
+        // Validate query parameters if we have both queryName and parameters
+        if (queryName && parametersNode) {
+            this.validateQueryParameters(queryName, parametersNode);
+        }
+        return this.typeContext.createRunQueryResultType(queryName || 'unknown');
+    }
+    /**
+     * Validate query parameters, especially date parameters
+     */
+    validateQueryParameters(queryName, parametersNode) {
+        // Get the query definition from component spec
+        const query = this.componentSpec?.dataRequirements?.queries?.find(q => q.name === queryName);
+        if (!query?.parameters) {
+            return;
+        }
+        // Build a map of parameter types with isRequired flag
+        const paramTypeMap = new Map();
+        for (const param of query.parameters) {
+            const extParam = param;
+            if (extParam.type) {
+                paramTypeMap.set(param.name.toLowerCase(), {
+                    type: mapSQLTypeToJSType(extParam.type),
+                    sqlType: extParam.type,
+                    isRequired: extParam.isRequired === true
+                });
+            }
+        }
+        // Validate each parameter value
+        for (const prop of parametersNode.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const paramName = prop.key.name;
+                const paramTypeInfo = paramTypeMap.get(paramName.toLowerCase());
+                if (!paramTypeInfo) {
+                    continue;
+                }
+                // Check for date/datetime types
+                const isDateType = ['date', 'datetime', 'datetime2', 'smalldatetime', 'datetimeoffset']
+                    .includes(paramTypeInfo.sqlType.toLowerCase());
+                if (isDateType) {
+                    // Handle string literals: StartDate: '2024-01-01'
+                    if (t.isStringLiteral(prop.value)) {
+                        this.validateDateParameter(paramName, prop.value.value, paramTypeInfo.isRequired, prop.loc);
+                    }
+                    // Handle variables: StartDate: effectiveStartDate
+                    else if (t.isIdentifier(prop.value)) {
+                        this.validateDateVariable(paramName, prop.value.name, paramTypeInfo.isRequired, prop.loc);
+                    }
+                    // Handle logical expressions: StartDate: startDate || appliedStartDate
+                    else if (t.isLogicalExpression(prop.value)) {
+                        // For logical expressions, check each operand
+                        this.validateDateLogicalExpression(paramName, prop.value, paramTypeInfo.isRequired, prop.loc);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Validate a date variable used as a parameter
+     */
+    validateDateVariable(paramName, variableName, isRequired, loc) {
+        // Look up the variable type in the type context
+        const varType = this.typeContext.getVariableType(variableName);
+        if (!varType) {
+            // Variable type unknown - could be a function parameter with no type info
+            // We'll allow this for now (no warning)
+            return;
+        }
+        // Handle 'unknown' type - common with React useState(null)
+        if (varType.type === 'unknown') {
+            // For optional parameters, unknown is acceptable (likely React state)
+            // For required parameters, emit a warning suggesting validation
+            if (isRequired) {
+                this.errors.push({
+                    type: 'warning',
+                    message: `Parameter "${paramName}" is required but variable "${variableName}" has unknown type. If "${variableName}" comes from React state (useState), ensure it's validated before calling RunQuery. Add a guard: if (!${variableName}) { return; }`,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    code: `// Add validation before RunQuery:\nif (!${variableName}) {\n  return; // or show error to user\n}`
+                });
+            }
+            // For optional parameters with unknown type, allow silently
+            return;
+        }
+        // Check if the variable is typed as string (dates are passed as ISO strings)
+        if (varType.type !== 'string') {
+            this.errors.push({
+                type: 'error',
+                message: `Parameter "${paramName}" expects a date string, but variable "${variableName}" has type "${varType.type}". Date parameters must be ISO date strings (e.g., '2024-01-01').`,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                code: `// Ensure ${variableName} contains a valid ISO date string`
+            });
+            return; // Stop further validation if type is wrong
+        }
+        // If we know the literal value (constant), validate it as a date string
+        if (varType.literalValue !== undefined && typeof varType.literalValue === 'string') {
+            this.validateDateParameter(paramName, varType.literalValue, isRequired, loc);
+            return; // Already validated the literal value
+        }
+        // If the variable is nullable and the parameter is required, flag it
+        if (isRequired && varType.nullable) {
+            this.errors.push({
+                type: 'error',
+                message: `Parameter "${paramName}" is required but variable "${variableName}" may be null/undefined. Ensure "${variableName}" always has a valid date value before calling RunQuery.`,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                code: `// Add validation:\nif (!${variableName}) {\n  throw new Error('${paramName} is required');\n}`
+            });
+        }
+    }
+    /**
+     * Validate a logical expression (e.g., startDate || appliedStartDate)
+     */
+    validateDateLogicalExpression(paramName, node, isRequired, loc) {
+        // For || (OR) expressions, validate that at least one operand provides a valid date
+        // For && (AND) expressions, validate the right operand (result of the expression)
+        // For ?? (nullish coalescing), validate the right operand (fallback value)
+        const operator = node.operator;
+        if (operator === '||' || operator === '??') {
+            // Validate both sides - if left is null/undefined, right will be used
+            if (t.isIdentifier(node.left)) {
+                this.validateDateVariable(paramName, node.left.name, false, loc); // Left can be nullable
+            }
+            else if (t.isStringLiteral(node.left)) {
+                this.validateDateParameter(paramName, node.left.value, false, loc);
+            }
+            if (t.isIdentifier(node.right)) {
+                this.validateDateVariable(paramName, node.right.name, isRequired, loc); // Right inherits requirement
+            }
+            else if (t.isStringLiteral(node.right)) {
+                this.validateDateParameter(paramName, node.right.value, isRequired, loc);
+            }
+        }
+        else if (operator === '&&') {
+            // For AND, only the right side matters as the result
+            if (t.isIdentifier(node.right)) {
+                this.validateDateVariable(paramName, node.right.name, isRequired, loc);
+            }
+            else if (t.isStringLiteral(node.right)) {
+                this.validateDateParameter(paramName, node.right.value, isRequired, loc);
+            }
+        }
+    }
+    /**
+     * Validate a date parameter value
+     */
+    validateDateParameter(paramName, value, isRequired, loc) {
+        // Empty strings are invalid for date parameters
+        if (value === '') {
+            let message;
+            let code;
+            if (isRequired) {
+                message = `Parameter "${paramName}" is required and must have a valid ISO date value (e.g., '2024-01-01'). Empty strings are not allowed.`;
+                code = `${paramName}: '2024-01-01'  // Required parameter`;
+            }
+            else {
+                message = `Parameter "${paramName}" is an optional date parameter but has an empty string value. Either provide a valid ISO date (e.g., '2024-01-01') or omit the parameter entirely from the Parameters object.`;
+                code = `// Option 1: Provide valid date\n${paramName}: '2024-01-01'\n\n// Option 2: Remove parameter entirely\nParameters: {\n  // ${paramName}: <omitted>\n}`;
+            }
+            this.errors.push({
+                type: 'error',
+                message,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                code
+            });
+            return;
+        }
+        // Validate ISO date format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS
+        const isoDatePattern = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/;
+        if (!isoDatePattern.test(value)) {
+            this.errors.push({
+                type: 'error',
+                message: `Parameter "${paramName}" is a date parameter but value '${value}' is not a valid ISO date format. Use YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS format.`,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                code: `${paramName}: '2024-01-01'  // or '2024-01-01T00:00:00'`
+            });
+            return;
+        }
+        // Validate that it's an actual valid date (not 2024-13-45)
+        const parsedDate = new Date(value);
+        if (isNaN(parsedDate.getTime())) {
+            this.errors.push({
+                type: 'error',
+                message: `Parameter "${paramName}" has an invalid date value '${value}'. The date format is correct but the date itself is invalid (e.g., month > 12, day > 31).`,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                code: `${paramName}: '2024-01-01'  // Use a valid date`
+            });
+        }
+    }
+    /**
+     * Infer type for member expressions
+     */
+    inferMemberExpressionType(node, path) {
+        const objectType = this.inferExpressionType(node.object, path);
+        // Array index access
+        if (node.computed && t.isNumericLiteral(node.property)) {
+            if (objectType.arrayElementType) {
+                return objectType.arrayElementType;
+            }
+        }
+        // Property access
+        if (t.isIdentifier(node.property)) {
+            const propName = node.property.name;
+            // Special case: .Results property on RunView/RunQuery result
+            // Must be checked BEFORE generic field lookup, because FieldTypeInfo
+            // can't carry arrayElementType (it's a simplified type), so the generic
+            // lookup would return bare { type: 'array' } without entity-row info.
+            if (propName === 'Results' && objectType.type === 'object') {
+                if (objectType.entityName) {
+                    const entityFields = this.typeContext.getEntityFieldTypesSync(objectType.entityName);
+                    return {
+                        type: 'array',
+                        arrayElementType: {
+                            type: 'entity-row',
+                            entityName: objectType.entityName,
+                            fields: entityFields.size > 0 ? entityFields : undefined
+                        }
+                    };
+                }
+                if (objectType.queryName) {
+                    const queryFields = this.typeContext.getQueryFieldTypes(objectType.queryName);
+                    return {
+                        type: 'array',
+                        arrayElementType: {
+                            type: 'query-row',
+                            queryName: objectType.queryName,
+                            fields: queryFields ?? undefined
+                        }
+                    };
+                }
+            }
+            // Check if the object has known fields
+            if (objectType.fields?.has(propName)) {
+                const field = objectType.fields.get(propName);
+                return { type: field.type, nullable: field.nullable };
+            }
+            // Array length
+            if (propName === 'length' && objectType.type === 'array') {
+                return StandardTypes.number;
+            }
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Infer type for binary expressions
+     */
+    inferBinaryExpressionType(node, path) {
+        const operator = node.operator;
+        // Comparison operators always return boolean
+        if (['==', '!=', '===', '!==', '<', '<=', '>', '>=', 'in', 'instanceof'].includes(operator)) {
+            return StandardTypes.boolean;
+        }
+        // Arithmetic operators return number
+        if (['-', '*', '/', '%', '**', '|', '&', '^', '<<', '>>', '>>>'].includes(operator)) {
+            return StandardTypes.number;
+        }
+        // + can be string or number
+        if (operator === '+') {
+            // node.left can be PrivateName in some cases, skip type inference for those
+            if (t.isPrivateName(node.left)) {
+                return StandardTypes.unknown;
+            }
+            const leftType = this.inferExpressionType(node.left, path);
+            const rightType = this.inferExpressionType(node.right, path);
+            if (leftType.type === 'string' || rightType.type === 'string') {
+                return StandardTypes.string;
+            }
+            if (leftType.type === 'number' && rightType.type === 'number') {
+                return StandardTypes.number;
+            }
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Infer type for unary expressions
+     */
+    inferUnaryExpressionType(node) {
+        const operator = node.operator;
+        if (operator === '!') {
+            return StandardTypes.boolean;
+        }
+        if (operator === 'typeof') {
+            return StandardTypes.string;
+        }
+        if (['+', '-', '~'].includes(operator)) {
+            return StandardTypes.number;
+        }
+        if (operator === 'void') {
+            return StandardTypes.undefined;
+        }
+        return StandardTypes.unknown;
+    }
+    /**
+     * Get inferred type for a variable by name
+     */
+    getVariableType(name) {
+        return this.typeContext.getVariableType(name);
+    }
+    /**
+     * Check if an expression is a specific type
+     */
+    isType(node, expectedType, path) {
+        const actualType = this.inferExpressionType(node, path);
+        return actualType.type === expectedType;
+    }
+}
+/**
+ * Convenience function to analyze an AST and return type context
+ */
+export async function analyzeTypes(ast, componentSpec, contextUser) {
+    const engine = new TypeInferenceEngine(componentSpec, contextUser);
+    return engine.analyze(ast);
+}
+//# sourceMappingURL=type-inference-engine.js.map