@memberjunction/react-test-harness 5.37.0 → 5.38.0

package/dist/lib/runtime-rules/data-result-validation.js

@@ -1,763 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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;
-};
-import { traverse } from '../lint-utils.js';
-import { RegisterClass } from '@memberjunction/global';
-import * as t from '@babel/types';
-import { BaseLintRule } from '../lint-rule.js';
-/**
- * Rule: data-result-validation
- *
- * Consolidates all RunView AND RunQuery RESULT USAGE validation into one rule.
- * Absorbs checks from:
- * - runview-runquery-result-validation (all)
- * - runquery-runview-spread-operator (all)
- * - runview-result-null-safety (all)
- *
- * Architecture:
- * - Phase 1: Collect result variables from await utilities.rv.RunView/RunViews/rq.RunQuery
- * - Phase 2: Validate usage of tracked result variables
- *
- * Checks:
- * 1. Invalid property access (.data, .rows, .records -> suggest .Results)
- * 2. Direct array method on result (.map, .filter, etc. -> use .Results.map)
- * 3. Passing result to setState without .Results
- * 4. Array.isArray pattern on result (always false since result is object)
- * 5. .length on result object
- * 6. Incorrect nested property access (result.data.entities)
- * 7. Destructuring invalid properties (const { data } = result)
- * 8. Weak fallback pattern (result?.records ?? result?.Rows ?? [])
- * 9. Spread operator on result object ([...result] or {...result})
- * 10. Missing Success check - .Results accessed without Success guard (medium severity)
- * 11. Incorrect optional check (.length on result)
- *
- * Severity: critical/high/medium
- * Applies to: all components
- */
-const RULE_NAME = 'data-result-validation';
-// Valid properties per result type
-const RUNVIEW_RESULT_PROPS = [
-    'Success', 'Results', 'UserViewRunID', 'RowCount', 'TotalRowCount', 'ExecutionTime', 'ErrorMessage',
-];
-const RUNQUERY_RESULT_PROPS = [
-    'QueryID', 'QueryName', 'Success', 'Results', 'RowCount', 'TotalRowCount',
-    'ExecutionTime', 'ErrorMessage', 'AppliedParameters', 'CacheHit', 'CacheKey', 'CacheTTLRemaining',
-];
-const VALID_RUNVIEW_RESULT = new Set(RUNVIEW_RESULT_PROPS);
-const VALID_RUNQUERY_RESULT = new Set(RUNQUERY_RESULT_PROPS);
-const SEARCH_RESULT_PROPS = [
-    'Success', 'Results', 'TotalCount', 'ElapsedMs', 'SourceCounts', 'Providers', 'ErrorMessage',
-];
-const VALID_SEARCH_RESULT = new Set(SEARCH_RESULT_PROPS);
-const ARRAY_METHODS = new Set(['map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every', 'sort', 'concat']);
-const ARRAY_EXPECTING_FUNCS = new Set([
-    'map', 'filter', 'forEach', 'reduce', 'sort', 'concat',
-    'processChartData', 'processData', 'transformData',
-    'setData', 'setItems', 'setResults', 'setRows',
-]);
-const INCORRECT_TO_CORRECT = {
-    data: 'Results', Data: 'Results',
-    rows: 'Results', Rows: 'Results',
-    records: 'Results', Records: 'Results',
-    items: 'Results', Items: 'Results',
-    values: 'Results', Values: 'Results',
-    result: 'Results', Result: 'Results',
-    resultSet: 'Results', ResultSet: 'Results',
-    dataset: 'Results', Dataset: 'Results',
-    response: 'Results', Response: 'Results',
-};
-// ── Phase 1: Collect result variables ────────────────────────────────
-/**
- * Attempts to extract utilities sub-object name and method name from a callee node.
- * Handles both MemberExpression (direct) and OptionalMemberExpression (optional chaining) patterns.
- * Returns [subObject, method] if matched, null otherwise.
- */
-function extractUtilitiesCallInfo(callee) {
-    // Get the method name from the outermost property
-    let methodName = null;
-    let objectNode = null;
-    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
-        methodName = callee.property.name;
-        objectNode = callee.object;
-    }
-    else if (t.isOptionalMemberExpression(callee) && t.isIdentifier(callee.property)) {
-        methodName = callee.property.name;
-        objectNode = callee.object;
-    }
-    if (!methodName || !objectNode)
-        return null;
-    // Check if the object is utilities.xxx (direct or optional)
-    let subObject = null;
-    if (t.isMemberExpression(objectNode) && t.isIdentifier(objectNode.object) &&
-        objectNode.object.name === 'utilities' && t.isIdentifier(objectNode.property)) {
-        subObject = objectNode.property.name;
-    }
-    else if (t.isOptionalMemberExpression(objectNode) && t.isIdentifier(objectNode.object) &&
-        objectNode.object.name === 'utilities' && t.isIdentifier(objectNode.property)) {
-        subObject = objectNode.property.name;
-    }
-    if (!subObject)
-        return null;
-    return [subObject, methodName];
-}
-/**
- * Resolves a MethodType from a utilities sub-object name and method name.
- */
-function resolveMethodType(subObject, method) {
-    if (subObject === 'rv' && (method === 'RunView' || method === 'RunViews')) {
-        return method;
-    }
-    if (subObject === 'rq' && method === 'RunQuery')
-        return 'RunQuery';
-    if (subObject === 'search' && method === 'Search')
-        return 'Search';
-    if (subObject === 'search' && method === 'PreviewSearch')
-        return 'PreviewSearch';
-    return null;
-}
-/**
- * Records a result variable from an AwaitExpression's parent (variable declarator or assignment).
- */
-function recordResultVariable(path, methodType, resultVariables) {
-    const parent = path.parent;
-    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
-        resultVariables.set(parent.id.name, {
-            line: parent.id.loc?.start.line || 0,
-            column: parent.id.loc?.start.column || 0,
-            method: methodType,
-            varName: parent.id.name,
-        });
-    }
-    else if (t.isAssignmentExpression(parent) && t.isIdentifier(parent.left)) {
-        resultVariables.set(parent.left.name, {
-            line: parent.left.loc?.start.line || 0,
-            column: parent.left.loc?.start.column || 0,
-            method: methodType,
-            varName: parent.left.name,
-        });
-    }
-}
-function collectResultVariables(ast) {
-    const resultVariables = new Map();
-    traverse(ast, {
-        AwaitExpression(path) {
-            const callExpr = path.node.argument;
-            // Handle both CallExpression and OptionalCallExpression
-            if (!t.isCallExpression(callExpr) && !t.isOptionalCallExpression(callExpr))
-                return;
-            const info = extractUtilitiesCallInfo(callExpr.callee);
-            if (!info)
-                return;
-            const methodType = resolveMethodType(info[0], info[1]);
-            if (!methodType)
-                return;
-            recordResultVariable(path, methodType, resultVariables);
-        },
-    });
-    return resultVariables;
-}
-// ── Scope-based binding check ────────────────────────────────────────
-function isVariableFromRunQueryOrView(path, varName, methodName) {
-    const binding = path.scope.getBinding(varName);
-    if (!binding)
-        return false;
-    const bindingPath = binding.path;
-    if (!t.isVariableDeclarator(bindingPath.node))
-        return false;
-    const init = bindingPath.node.init;
-    if (!init)
-        return false;
-    // Handle both CallExpression and OptionalCallExpression inside AwaitExpression
-    if (t.isAwaitExpression(init) && (t.isCallExpression(init.argument) || t.isOptionalCallExpression(init.argument))) {
-        const call = init.argument;
-        const info = extractUtilitiesCallInfo(call.callee);
-        if (info) {
-            const [subObj, calledMethod] = info;
-            if (methodName === 'RunView' && subObj === 'rv' && (calledMethod === 'RunView' || calledMethod === 'RunViews'))
-                return true;
-            if (methodName === 'RunQuery' && subObj === 'rq' && calledMethod === 'RunQuery')
-                return true;
-            if (methodName === 'Search' && subObj === 'search' && calledMethod === 'Search')
-                return true;
-            if (methodName === 'PreviewSearch' && subObj === 'search' && calledMethod === 'PreviewSearch')
-                return true;
-        }
-        // Fallback: check just the method name without full utilities path
-        if (t.isCallExpression(call) && t.isMemberExpression(call.callee) && t.isIdentifier(call.callee.property)) {
-            const calledMethod = call.callee.property.name;
-            const isFromMethod = calledMethod === methodName || (methodName === 'RunView' && calledMethod === 'RunViews');
-            return isFromMethod;
-        }
-    }
-    return false;
-}
-// ── Success guard checking ───────────────────────────────────────────
-function testChecksSuccess(test, varName) {
-    if (t.isMemberExpression(test) &&
-        t.isIdentifier(test.object) &&
-        test.object.name === varName &&
-        t.isIdentifier(test.property) &&
-        (test.property.name === 'Success' || test.property.name === 'Results'))
-        return true;
-    if (t.isOptionalMemberExpression(test) &&
-        t.isIdentifier(test.object) &&
-        test.object.name === varName &&
-        t.isIdentifier(test.property) &&
-        (test.property.name === 'Success' || test.property.name === 'Results'))
-        return true;
-    if (t.isLogicalExpression(test) && test.operator === '&&') {
-        return testChecksSuccess(test.left, varName) || testChecksSuccess(test.right, varName);
-    }
-    return false;
-}
-function testChecksNegatedSuccess(test, varName) {
-    if (t.isUnaryExpression(test) && test.operator === '!') {
-        return testChecksSuccess(test.argument, varName);
-    }
-    return false;
-}
-function blockContainsReturn(node) {
-    if (t.isReturnStatement(node))
-        return true;
-    if (t.isBlockStatement(node))
-        return node.body.some(s => t.isReturnStatement(s));
-    return false;
-}
-function isDescendantOf(targetNode, containerNode) {
-    if (targetNode === containerNode)
-        return true;
-    let found = false;
-    traverse(containerNode, {
-        enter(innerPath) {
-            if (innerPath.node === targetNode) {
-                found = true;
-                innerPath.stop();
-            }
-        },
-        noScope: true,
-    });
-    return found;
-}
-function isPrecededByEarlyReturnGuard(path, varName) {
-    let blockPath = path;
-    while (blockPath && !blockPath.isBlockStatement() && !blockPath.isProgram()) {
-        blockPath = blockPath.parentPath;
-    }
-    if (!blockPath)
-        return false;
-    const container = blockPath.node;
-    const body = t.isBlockStatement(container) ? container.body : t.isProgram(container) ? container.body : [];
-    const targetLine = path.node.loc?.start.line ?? 0;
-    for (const stmt of body) {
-        if ((stmt.loc?.start.line ?? 0) >= targetLine)
-            break;
-        if (t.isIfStatement(stmt) &&
-            testChecksNegatedSuccess(stmt.test, varName) &&
-            blockContainsReturn(stmt.consequent))
-            return true;
-    }
-    return false;
-}
-function isInsideSuccessGuard(path, varName) {
-    let current = path.parentPath;
-    while (current) {
-        if (current.isIfStatement()) {
-            if (testChecksSuccess(current.node.test, varName) && isDescendantOf(path.node, current.node.consequent)) {
-                return true;
-            }
-        }
-        if (current.isLogicalExpression() && current.node.operator === '&&') {
-            if (testChecksSuccess(current.node.left, varName))
-                return true;
-        }
-        if (current.isConditionalExpression()) {
-            if (testChecksSuccess(current.node.test, varName))
-                return true;
-        }
-        current = current.parentPath;
-    }
-    return isPrecededByEarlyReturnGuard(path, varName);
-}
-// ── Property access validation helper ────────────────────────────────
-function validatePropertyAccess(objName, propName, isFromRunQuery, isFromRunView, isFromSearch, line, column, code, violations) {
-    if (!isFromRunQuery && !isFromRunView && !isFromSearch)
-        return;
-    const isValidQueryProp = VALID_RUNQUERY_RESULT.has(propName);
-    const isValidViewProp = VALID_RUNVIEW_RESULT.has(propName);
-    const isValidSearchProp = VALID_SEARCH_RESULT.has(propName);
-    if (isFromRunQuery && !isValidQueryProp) {
-        const suggestion = INCORRECT_TO_CORRECT[propName];
-        violations.push({
-            rule: RULE_NAME,
-            severity: 'critical',
-            line, column,
-            message: suggestion
-                ? `RunQuery results don't have a ".${propName}" property. Use ".${suggestion}" instead. Change "${objName}.${propName}" to "${objName}.${suggestion}"`
-                : `Invalid property "${propName}" on RunQuery result. Valid properties: ${RUNQUERY_RESULT_PROPS.join(', ')}`,
-            code,
-        });
-    }
-    else if (isFromRunView && !isValidViewProp) {
-        const suggestion = INCORRECT_TO_CORRECT[propName];
-        violations.push({
-            rule: RULE_NAME,
-            severity: 'critical',
-            line, column,
-            message: suggestion
-                ? `RunView results don't have a ".${propName}" property. Use ".${suggestion}" instead. Change "${objName}.${propName}" to "${objName}.${suggestion}"`
-                : `Invalid property "${propName}" on RunView result. Valid properties: ${RUNVIEW_RESULT_PROPS.join(', ')}`,
-            code,
-        });
-    }
-    else if (isFromSearch && !isValidSearchProp) {
-        const suggestion = INCORRECT_TO_CORRECT[propName];
-        violations.push({
-            rule: RULE_NAME,
-            severity: 'critical',
-            line, column,
-            message: suggestion
-                ? `Search results don't have a ".${propName}" property. Use ".${suggestion}" instead. Change "${objName}.${propName}" to "${objName}.${suggestion}"`
-                : `Invalid property "${propName}" on Search result. Valid properties: ${SEARCH_RESULT_PROPS.join(', ')}`,
-            code,
-        });
-    }
-}
-// ── Main Rule ────────────────────────────────────────────────────────
-let DataResultValidationRule = class DataResultValidationRule extends BaseLintRule {
-    get Name() { return 'data-result-validation'; }
-    get AppliesTo() { return 'all'; }
-    Test(ast) {
-        const violations = [];
-        // Phase 1: Collect result variables
-        const resultVariables = collectResultVariables(ast);
-        if (resultVariables.size === 0)
-            return violations;
-        // Collect simple set for null-safety (just variable names)
-        const resultVarNames = new Set(resultVariables.keys());
-        // Phase 2: Validate usage
-        traverse(ast, {
-            // ── Array methods + setState + array-expecting funcs ──────
-            CallExpression(path) {
-                const callee = path.node.callee;
-                // Check 2: result.map(), result.filter(), etc.
-                if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && t.isIdentifier(callee.property)) {
-                    const objName = callee.object.name;
-                    const methodName = callee.property.name;
-                    if (ARRAY_METHODS.has(methodName)) {
-                        const isFromRunView = isVariableFromRunQueryOrView(path, objName, 'RunView');
-                        const isFromRunQuery = isVariableFromRunQueryOrView(path, objName, 'RunQuery');
-                        const isFromSearch = isVariableFromRunQueryOrView(path, objName, 'Search');
-                        const isFromPreviewSearch = isVariableFromRunQueryOrView(path, objName, 'PreviewSearch');
-                        if (isFromRunView || isFromRunQuery || isFromSearch || isFromPreviewSearch) {
-                            const methodType = isFromRunView ? 'RunView' : isFromRunQuery ? 'RunQuery' : isFromSearch ? 'Search' : 'PreviewSearch';
-                            violations.push({
-                                rule: RULE_NAME,
-                                severity: 'critical',
-                                line: path.node.loc?.start.line || 0,
-                                column: path.node.loc?.start.column || 0,
-                                message: `Cannot call array method "${methodName}" directly on ${methodType} result. Use "${objName}.Results.${methodName}(...)" instead. ${methodType} returns an object with { Success, Results, ... }, not an array.`,
-                                code: `${objName}.${methodName}(...)`,
-                            });
-                        }
-                    }
-                }
-                // Check 3 & 4: setState patterns
-                if (t.isIdentifier(callee)) {
-                    const funcName = callee.name;
-                    const setStatePatterns = [/^set[A-Z]/, /^update[A-Z]/];
-                    const isSetStateFunction = setStatePatterns.some((pattern) => pattern.test(funcName));
-                    if (isSetStateFunction && path.node.arguments.length > 0) {
-                        const firstArg = path.node.arguments[0];
-                        // Check 4: Array.isArray ternary pattern in setState
-                        if (t.isConditionalExpression(firstArg)) {
-                            const test = firstArg.test;
-                            const consequent = firstArg.consequent;
-                            if (t.isCallExpression(test) &&
-                                t.isMemberExpression(test.callee) &&
-                                t.isIdentifier(test.callee.object) &&
-                                test.callee.object.name === 'Array' &&
-                                t.isIdentifier(test.callee.property) &&
-                                test.callee.property.name === 'isArray' &&
-                                test.arguments.length === 1 &&
-                                t.isIdentifier(test.arguments[0])) {
-                                const varName = test.arguments[0].name;
-                                if (resultVariables.has(varName) && t.isIdentifier(consequent) && consequent.name === varName) {
-                                    const resultInfo = resultVariables.get(varName);
-                                    violations.push({
-                                        rule: RULE_NAME,
-                                        severity: 'critical',
-                                        line: firstArg.loc?.start.line || 0,
-                                        column: firstArg.loc?.start.column || 0,
-                                        message: `Passing ${resultInfo.method} result with incorrect Array.isArray check to ${funcName}. This will always pass an empty array because ${resultInfo.method} returns an object, not an array.
-
-Correct pattern:
-  if (${varName}.Success) {
-    ${funcName}(${varName}.Results || []);
-  } else {
-    console.error('Failed to load data:', ${varName}.ErrorMessage);
-  }`,
-                                        code: `${funcName}(Array.isArray(${varName}) ? ${varName} : [])`,
-                                    });
-                                }
-                            }
-                        }
-                        // Check 3: Passing result directly to setState
-                        if (t.isIdentifier(firstArg) && resultVariables.has(firstArg.name)) {
-                            const resultInfo = resultVariables.get(firstArg.name);
-                            violations.push({
-                                rule: RULE_NAME,
-                                severity: 'critical',
-                                line: firstArg.loc?.start.line || 0,
-                                column: firstArg.loc?.start.column || 0,
-                                message: `Passing ${resultInfo.method} result directly to ${funcName}. Use "${firstArg.name}.Results" or check "${firstArg.name}.Success" first. ${resultInfo.method} returns { Success, Results, ErrorMessage }, not the data array.`,
-                                code: `${funcName}(${firstArg.name})`,
-                            });
-                        }
-                    }
-                }
-                // Check: passing result to array-expecting functions
-                for (const arg of path.node.arguments) {
-                    if (!t.isIdentifier(arg) || !resultVariables.has(arg.name))
-                        continue;
-                    const resultInfo = resultVariables.get(arg.name);
-                    let funcName = '';
-                    if (t.isIdentifier(path.node.callee)) {
-                        funcName = path.node.callee.name;
-                    }
-                    else if (t.isMemberExpression(path.node.callee) && t.isIdentifier(path.node.callee.property)) {
-                        funcName = path.node.callee.property.name;
-                    }
-                    if (ARRAY_EXPECTING_FUNCS.has(funcName.toLowerCase()) ||
-                        Array.from(ARRAY_EXPECTING_FUNCS).some((f) => funcName.toLowerCase().includes(f.toLowerCase()))) {
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'critical',
-                            line: arg.loc?.start.line || 0,
-                            column: arg.loc?.start.column || 0,
-                            message: `Passing ${resultInfo.method} result object directly to ${funcName}() which expects an array.
-Correct pattern:
-  if (${resultInfo.varName}?.Success) {
-    ${funcName}(${resultInfo.varName}.Results);
-  } else {
-    console.error('${resultInfo.method} failed:', ${resultInfo.varName}?.ErrorMessage);
-    ${funcName}([]); // Provide empty array as fallback
-  }`,
-                            code: `${funcName}(${arg.name})`,
-                        });
-                    }
-                }
-            },
-            // ── Property access (MemberExpression) ─────────────────────
-            MemberExpression(path) {
-                if (!t.isIdentifier(path.node.object) || !t.isIdentifier(path.node.property))
-                    return;
-                const objName = path.node.object.name;
-                const propName = path.node.property.name;
-                const hasBinding = path.scope.hasBinding(objName);
-                const isFromRunQuery = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunQuery');
-                const isFromRunView = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunView');
-                const isFromSearch = hasBinding && (isVariableFromRunQueryOrView(path, objName, 'Search') || isVariableFromRunQueryOrView(path, objName, 'PreviewSearch'));
-                // Check 5: .length on result
-                if (propName === 'length' && resultVariables.has(objName)) {
-                    const resultInfo = resultVariables.get(objName);
-                    violations.push({
-                        rule: RULE_NAME,
-                        severity: 'critical',
-                        line: path.node.loc?.start.line || 0,
-                        column: path.node.loc?.start.column || 0,
-                        message: `Cannot check .length on ${resultInfo.method} result directly. ${resultInfo.method} returns an object with Success and Results properties.
-Correct pattern:
-  if (${resultInfo.varName}?.Success && ${resultInfo.varName}?.Results?.length > 0) {
-    // Process ${resultInfo.varName}.Results array
-  }`,
-                        code: `${objName}.length`,
-                    });
-                }
-                // Check 1: Invalid property access
-                validatePropertyAccess(objName, propName, isFromRunQuery, isFromRunView, isFromSearch, path.node.loc?.start.line || 0, path.node.loc?.start.column || 0, `${objName}.${propName}`, violations);
-                // Check 6: Nested incorrect access like result.data.entities
-                if ((isFromRunQuery || isFromRunView || isFromSearch) &&
-                    t.isMemberExpression(path.parent) &&
-                    t.isIdentifier(path.parent.property) &&
-                    (propName === 'data' || propName === 'Data')) {
-                    const nestedProp = path.parent.property.name;
-                    const sourceType = isFromSearch ? 'Search' : 'RunQuery/RunView';
-                    violations.push({
-                        rule: RULE_NAME,
-                        severity: 'critical',
-                        line: path.parent.loc?.start.line || 0,
-                        column: path.parent.loc?.start.column || 0,
-                        message: `Incorrect nested property access "${objName}.${propName}.${nestedProp}". ${sourceType} results use ".Results" directly for the data array. Change to "${objName}.Results"`,
-                        code: `${objName}.${propName}.${nestedProp}`,
-                    });
-                }
-                // Check 10: Missing Success check (null safety)
-                if (propName === 'Results' && resultVarNames.has(objName)) {
-                    if (!isInsideSuccessGuard(path, objName)) {
-                        const resultInfo = resultVariables.get(objName);
-                        const sourceDesc = resultInfo && (resultInfo.method === 'Search' || resultInfo.method === 'PreviewSearch')
-                            ? 'Search' : 'RunView/RunQuery';
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'medium',
-                            line: path.node.loc?.start.line ?? 0,
-                            column: path.node.loc?.start.column ?? 0,
-                            message: `Accessing "${objName}.Results" without checking "${objName}.Success" first. ${sourceDesc} can fail, and .Results may be undefined when Success is false.`,
-                            code: `${objName}.Results`,
-                            suggestion: {
-                                text: `Wrap in a Success check before accessing Results`,
-                                example: `if (${objName}.Success) {\n  ${objName}.Results.map(...);\n} else {\n  console.error('Query failed:', ${objName}.ErrorMessage);\n}`,
-                            },
-                        });
-                    }
-                }
-            },
-            // ── Optional member expressions ────────────────────────────
-            OptionalMemberExpression(path) {
-                if (!t.isIdentifier(path.node.object) || !t.isIdentifier(path.node.property))
-                    return;
-                const objName = path.node.object.name;
-                const propName = path.node.property.name;
-                const hasBinding = path.scope.hasBinding(objName);
-                const isFromRunQuery = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunQuery');
-                const isFromRunView = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunView');
-                const isFromSearch = hasBinding && (isVariableFromRunQueryOrView(path, objName, 'Search') || isVariableFromRunQueryOrView(path, objName, 'PreviewSearch'));
-                // Check 1 (optional chaining variant)
-                validatePropertyAccess(objName, propName, isFromRunQuery, isFromRunView, isFromSearch, path.node.loc?.start.line || 0, path.node.loc?.start.column || 0, `${objName}?.${propName}`, violations);
-                // Note: result?.Results is inherently null-safe — do NOT flag for missing Success check
-            },
-            // ── Check 8: Weak fallback patterns ────────────────────────
-            LogicalExpression(path) {
-                if (path.node.operator !== '??')
-                    return;
-                const invalidAccesses = [];
-                const checkNode = (node) => {
-                    if (t.isOptionalMemberExpression(node) && t.isIdentifier(node.object) && t.isIdentifier(node.property)) {
-                        const objName = node.object.name;
-                        const propName = node.property.name;
-                        const hasBinding = path.scope.hasBinding(objName);
-                        const isFromRunQuery = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunQuery');
-                        const isFromRunView = hasBinding && isVariableFromRunQueryOrView(path, objName, 'RunView');
-                        const isFromSearch = hasBinding && (isVariableFromRunQueryOrView(path, objName, 'Search') || isVariableFromRunQueryOrView(path, objName, 'PreviewSearch'));
-                        if (isFromRunQuery || isFromRunView || isFromSearch) {
-                            const isValidQueryProp = VALID_RUNQUERY_RESULT.has(propName);
-                            const isValidViewProp = VALID_RUNVIEW_RESULT.has(propName);
-                            const isValidSearchProp = VALID_SEARCH_RESULT.has(propName);
-                            if ((isFromRunQuery && !isValidQueryProp) || (isFromRunView && !isValidViewProp) || (isFromSearch && !isValidSearchProp)) {
-                                invalidAccesses.push({ objName, propName, line: node.loc?.start.line || 0 });
-                            }
-                        }
-                    }
-                    else if (t.isLogicalExpression(node) && node.operator === '??') {
-                        checkNode(node.left);
-                        checkNode(node.right);
-                    }
-                };
-                checkNode(path.node);
-                if (invalidAccesses.length >= 2) {
-                    const objName = invalidAccesses[0].objName;
-                    const props = invalidAccesses.map((a) => a.propName).join(', ');
-                    violations.push({
-                        rule: RULE_NAME,
-                        severity: 'critical',
-                        line: path.node.loc?.start.line || 0,
-                        column: path.node.loc?.start.column || 0,
-                        message: `Weak fallback pattern detected: "${objName}?.${invalidAccesses[0].propName} ?? ${objName}?.${invalidAccesses[1].propName} ?? ..." uses multiple INVALID properties (${props}). This masks the real issue. Use "${objName}?.Results ?? []" instead.`,
-                        code: path.toString().substring(0, 100),
-                    });
-                }
-            },
-            // ── Check 7: Destructuring invalid properties ──────────────
-            VariableDeclarator(path) {
-                if (!t.isObjectPattern(path.node.id) || !t.isIdentifier(path.node.init))
-                    return;
-                const sourceName = path.node.init.name;
-                const hasBinding = path.scope.hasBinding(sourceName);
-                const isFromRunQuery = hasBinding && isVariableFromRunQueryOrView(path, sourceName, 'RunQuery');
-                const isFromRunView = hasBinding && isVariableFromRunQueryOrView(path, sourceName, 'RunView');
-                const isFromSearch = hasBinding && (isVariableFromRunQueryOrView(path, sourceName, 'Search') || isVariableFromRunQueryOrView(path, sourceName, 'PreviewSearch'));
-                if (!isFromRunQuery && !isFromRunView && !isFromSearch)
-                    return;
-                for (const prop of path.node.id.properties) {
-                    if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key))
-                        continue;
-                    const propName = prop.key.name;
-                    const isValidQueryProp = VALID_RUNQUERY_RESULT.has(propName);
-                    const isValidViewProp = VALID_RUNVIEW_RESULT.has(propName);
-                    const isValidSearchProp = VALID_SEARCH_RESULT.has(propName);
-                    if (isFromRunQuery && !isValidQueryProp) {
-                        const suggestion = INCORRECT_TO_CORRECT[propName];
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'critical',
-                            line: prop.loc?.start.line || 0,
-                            column: prop.loc?.start.column || 0,
-                            message: suggestion
-                                ? `Destructuring invalid property "${propName}" from RunQuery result. Use "${suggestion}" instead.`
-                                : `Destructuring invalid property "${propName}" from RunQuery result. Valid properties: ${RUNQUERY_RESULT_PROPS.join(', ')}`,
-                            code: `{ ${propName} }`,
-                        });
-                    }
-                    else if (isFromRunView && !isValidViewProp) {
-                        const suggestion = INCORRECT_TO_CORRECT[propName];
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'critical',
-                            line: prop.loc?.start.line || 0,
-                            column: prop.loc?.start.column || 0,
-                            message: suggestion
-                                ? `Destructuring invalid property "${propName}" from RunView result. Use "${suggestion}" instead.`
-                                : `Destructuring invalid property "${propName}" from RunView result. Valid properties: ${RUNVIEW_RESULT_PROPS.join(', ')}`,
-                            code: `{ ${propName} }`,
-                        });
-                    }
-                    else if (isFromSearch && !isValidSearchProp) {
-                        const suggestion = INCORRECT_TO_CORRECT[propName];
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'critical',
-                            line: prop.loc?.start.line || 0,
-                            column: prop.loc?.start.column || 0,
-                            message: suggestion
-                                ? `Destructuring invalid property "${propName}" from Search result. Use "${suggestion}" instead.`
-                                : `Destructuring invalid property "${propName}" from Search result. Valid properties: ${SEARCH_RESULT_PROPS.join(', ')}`,
-                            code: `{ ${propName} }`,
-                        });
-                    }
-                }
-            },
-            // ── Check 4 & 11: ConditionalExpression patterns ───────────
-            ConditionalExpression(path) {
-                const test = path.node.test;
-                const consequent = path.node.consequent;
-                const alternate = path.node.alternate;
-                if (t.isCallExpression(test) &&
-                    t.isMemberExpression(test.callee) &&
-                    t.isIdentifier(test.callee.object) &&
-                    test.callee.object.name === 'Array' &&
-                    t.isIdentifier(test.callee.property) &&
-                    test.callee.property.name === 'isArray' &&
-                    test.arguments.length === 1 &&
-                    t.isIdentifier(test.arguments[0])) {
-                    const varName = test.arguments[0].name;
-                    if (resultVariables.has(varName) &&
-                        t.isIdentifier(consequent) &&
-                        consequent.name === varName &&
-                        t.isArrayExpression(alternate) &&
-                        alternate.elements.length === 0) {
-                        const resultInfo = resultVariables.get(varName);
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'critical',
-                            line: test.loc?.start.line || 0,
-                            column: test.loc?.start.column || 0,
-                            message: `${resultInfo.method} never returns an array directly. The pattern "Array.isArray(${varName}) ? ${varName} : []" will always evaluate to [] because ${varName} is an object with { Success, Results, ErrorMessage }.
-
-Correct patterns:
-  // Option 1: Simple with fallback
-  ${varName}.Results || []
-
-  // Option 2: Check success first
-  if (${varName}.Success) {
-    setData(${varName}.Results || []);
-  } else {
-    console.error('Failed:', ${varName}.ErrorMessage);
-    setData([]);
-  }`,
-                            code: `Array.isArray(${varName}) ? ${varName} : []`,
-                        });
-                    }
-                }
-            },
-            // ── Check 9: Spread operator on result object ──────────────
-            SpreadElement(path) {
-                if (!t.isIdentifier(path.node.argument))
-                    return;
-                const varName = path.node.argument.name;
-                if (!resultVariables.has(varName))
-                    return;
-                const resultInfo = resultVariables.get(varName);
-                violations.push({
-                    rule: RULE_NAME,
-                    severity: 'critical',
-                    line: path.node.loc?.start.line || 0,
-                    column: path.node.loc?.start.column || 0,
-                    message: `Cannot use spread operator on ${resultInfo.method} result object. Use ...${varName}.Results to spread the data array.
-
-Correct pattern:
-  const allData = [...existingData, ...${varName}.Results];
-
-  // Or with null safety:
-  const allData = [...existingData, ...(${varName}.Results || [])];`,
-                    code: `...${varName}`,
-                });
-            },
-            // ── Check 11: IfStatement patterns ─────────────────────────
-            IfStatement(path) {
-                const test = path.node.test;
-                // Pattern: if (result) - check for Results access without Success check
-                if (t.isIdentifier(test) && resultVariables.has(test.name)) {
-                    const resultInfo = resultVariables.get(test.name);
-                    let checksSuccess = false;
-                    let checksResults = false;
-                    path.traverse({
-                        MemberExpression(innerPath) {
-                            if (t.isIdentifier(innerPath.node.object) && innerPath.node.object.name === test.name) {
-                                const prop = t.isIdentifier(innerPath.node.property) ? innerPath.node.property.name : '';
-                                if (prop === 'Success')
-                                    checksSuccess = true;
-                                if (prop === 'Results')
-                                    checksResults = true;
-                            }
-                        },
-                    });
-                    if (checksResults && !checksSuccess) {
-                        violations.push({
-                            rule: RULE_NAME,
-                            severity: 'high',
-                            line: test.loc?.start.line || 0,
-                            column: test.loc?.start.column || 0,
-                            message: `Checking ${resultInfo.method} result without verifying Success property.
-Correct pattern:
-  if (${resultInfo.varName}?.Success) {
-    const data = ${resultInfo.varName}.Results;
-  } else {
-    // Handle error: ${resultInfo.varName}.ErrorMessage
-  }`,
-                            code: `if (${test.name})`,
-                        });
-                    }
-                }
-                // Pattern: if (result?.length)
-                if (t.isOptionalMemberExpression(test) &&
-                    t.isIdentifier(test.object) &&
-                    t.isIdentifier(test.property) &&
-                    test.property.name === 'length' &&
-                    resultVariables.has(test.object.name)) {
-                    const resultInfo = resultVariables.get(test.object.name);
-                    violations.push({
-                        rule: RULE_NAME,
-                        severity: 'critical',
-                        line: test.loc?.start.line || 0,
-                        column: test.loc?.start.column || 0,
-                        message: `Incorrect check: "${test.object.name}?.length" on ${resultInfo.method} result.
-Correct pattern:
-  if (${resultInfo.varName}?.Success && ${resultInfo.varName}?.Results?.length > 0) {
-    const processedData = processChartData(${resultInfo.varName}.Results);
-  }`,
-                        code: `if (${test.object.name}?.length)`,
-                    });
-                }
-            },
-        });
-        return violations;
-    }
-};
-DataResultValidationRule = __decorate([
-    RegisterClass(BaseLintRule, 'data-result-validation')
-], DataResultValidationRule);
-export { DataResultValidationRule };
-//# sourceMappingURL=data-result-validation.js.map