@memberjunction/react-test-harness 2.92.0 → 2.94.0

package/dist/lib/component-linter.d.ts

@@ -1,5 +1,6 @@
 import { ComponentSpec } from '@memberjunction/interactive-component-types';
 import type { UserInfo } from '@memberjunction/core';
+import { ComponentExecutionOptions } from './component-runner';
 export interface LintResult {
     success: boolean;
     violations: Violation[];
@@ -29,7 +30,7 @@ export declare class ComponentLinter {
     private static containsReturn;
     private static isVariableFromRunQueryOrView;
     private static universalComponentRules;
-    static lintComponent(code: string, componentName: string, componentSpec?: ComponentSpec, isRootComponent?: boolean, contextUser?: UserInfo, debugMode?: boolean): Promise<LintResult>;
+    static lintComponent(code: string, componentName: string, componentSpec?: ComponentSpec, isRootComponent?: boolean, contextUser?: UserInfo, debugMode?: boolean, options?: ComponentExecutionOptions): Promise<LintResult>;
     private static validateDataRequirements;
     private static getFunctionName;
     private static deduplicateViolations;

package/dist/lib/component-linter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-linter.d.ts","sourceRoot":"","sources":["../../src/lib/component-linter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAiC,MAAM,6CAA6C,CAAC;AAG3G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,WAAW,EAAE,aAAa,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA+ED,qBAAa,eAAe;IAE1B,OAAO,CAAC,MAAM,CAAC,cAAc;IAoB7B,OAAO,CAAC,MAAM,CAAC,4BAA4B;IA2C3C,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAw6HpC;WAEkB,aAAa,CAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,aAAa,EAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,WAAW,CAAC,EAAE,QAAQ,EACtB,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,UAAU,CAAC;IA0GtB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAoXvC,OAAO,CAAC,MAAM,CAAC,eAAe;IA2B9B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAyBpC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAw/BrC;;OAEG;mBACkB,qBAAqB;IA2H1C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAiEzC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA8ClC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA8GpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoElC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;CAuFzC"}
+{"version":3,"file":"component-linter.d.ts","sourceRoot":"","sources":["../../src/lib/component-linter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAiC,MAAM,6CAA6C,CAAC;AAG3G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,WAAW,EAAE,aAAa,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA+ED,qBAAa,eAAe;IAE1B,OAAO,CAAC,MAAM,CAAC,cAAc;IAoB7B,OAAO,CAAC,MAAM,CAAC,4BAA4B;IA2C3C,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAm7IpC;WAEkB,aAAa,CAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,aAAa,EAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,WAAW,CAAC,EAAE,QAAQ,EACtB,SAAS,CAAC,EAAE,OAAO,EACnB,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,UAAU,CAAC;IA0GtB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAoXvC,OAAO,CAAC,MAAM,CAAC,eAAe;IA2B9B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAyBpC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAw/BrC;;OAEG;mBACkB,qBAAqB;IA2H1C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAiEzC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA8ClC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA8GpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoElC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;CAuFzC"}

package/dist/lib/component-linter.js

@@ -152,7 +152,7 @@ class ComponentLinter {
         }
         return isFromMethod;
     }
-    static async lintComponent(code, componentName, componentSpec, isRootComponent, contextUser, debugMode) {
+    static async lintComponent(code, componentName, componentSpec, isRootComponent, contextUser, debugMode, options) {
         try {
             const ast = parser.parse(code, {
                 sourceType: 'module',
@@ -173,7 +173,7 @@ class ComponentLinter {
             const violations = [];
             // Run each rule
             for (const rule of rules) {
-                const ruleViolations = rule.test(ast, componentName, componentSpec);
+                const ruleViolations = rule.test(ast, componentName, componentSpec, options);
                 violations.push(...ruleViolations);
             }
             // Add data requirements validation if componentSpec is provided
@@ -3649,9 +3649,8 @@ ComponentLinter.universalComponentRules = [
             const violations = [];
             // Valid properties for RunView/RunViews
             const validRunViewProps = new Set([
-                'ViewID', 'ViewName', 'EntityName', 'ExtraFilter', 'OrderBy', 'Fields',
-                'MaxRows', 'StartRow', 'ResultType', 'UserSearchString', 'ForceAuditLog', 'AuditLogDescription',
-                'ResultType'
+                'EntityName', 'ExtraFilter', 'OrderBy', 'Fields',
+                'MaxRows', 'StartRow', 'ResultType'
             ]);
             // Valid properties for RunQuery
             const validRunQueryProps = new Set([
@@ -3729,20 +3728,11 @@ ComponentLinter.universalComponentRules = [
                             }
                             // Check each config for invalid properties and required fields
                             for (const config of configs) {
-                                // Check for required properties (must have ViewID, ViewName, ViewEntity, or EntityName)
-                                let hasViewID = false;
-                                let hasViewName = false;
-                                let hasViewEntity = false;
+                                // Check for required properties (must have EntityName)
                                 let hasEntityName = false;
                                 for (const prop of config.properties) {
                                     if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
                                         const propName = prop.key.name;
-                                        if (propName === 'ViewID')
-                                            hasViewID = true;
-                                        if (propName === 'ViewName')
-                                            hasViewName = true;
-                                        if (propName === 'ViewEntity')
-                                            hasViewEntity = true;
                                         if (propName === 'EntityName')
                                             hasEntityName = true;
                                         if (!validRunViewProps.has(propName)) {
@@ -3753,6 +3743,18 @@ ComponentLinter.universalComponentRules = [
                                                 message = `${methodName} does not support 'Parameters'. Use 'ExtraFilter' for WHERE clauses.`;
                                                 fix = `Replace 'Parameters' with 'ExtraFilter' and format as SQL WHERE clause`;
                                             }
+                                            else if (propName === 'ViewID' || propName === 'ViewName') {
+                                                message = `${methodName} property '${propName}' is not allowed in components. Use 'EntityName' instead.`;
+                                                fix = `Replace '${propName}' with 'EntityName' and specify the entity name`;
+                                            }
+                                            else if (propName === 'UserSearchString') {
+                                                message = `${methodName} property 'UserSearchString' is not allowed in components. Use 'ExtraFilter' for filtering.`;
+                                                fix = `Remove 'UserSearchString' and use 'ExtraFilter' with appropriate WHERE clause`;
+                                            }
+                                            else if (propName === 'ForceAuditLog' || propName === 'AuditLogDescription') {
+                                                message = `${methodName} property '${propName}' is not allowed in components.`;
+                                                fix = `Remove '${propName}' property`;
+                                            }
                                             else if (propName === 'GroupBy') {
                                                 message = `${methodName} does not support 'GroupBy'. Use RunQuery with a pre-defined query for aggregations.`;
                                                 fix = `Remove 'GroupBy' and use RunQuery instead for aggregated data`;
@@ -3772,14 +3774,14 @@ ComponentLinter.universalComponentRules = [
                                         }
                                     }
                                 }
-                                // Check that at least one required property is present
-                                if (!hasViewID && !hasViewName && !hasViewEntity && !hasEntityName) {
+                                // Check that EntityName is present (required property)
+                                if (!hasEntityName) {
                                     violations.push({
                                         rule: 'runview-runquery-valid-properties',
                                         severity: 'critical',
                                         line: config.loc?.start.line || 0,
                                         column: config.loc?.start.column || 0,
-                                        message: `${methodName} requires one of: ViewID, ViewName, ViewEntity, or EntityName. Add one to identify what data to retrieve.`,
+                                        message: `${methodName} requires 'EntityName' property. Add EntityName to identify what data to retrieve.`,
                                         code: `${methodName}({ ... })`
                                     });
                                 }
@@ -5635,6 +5637,443 @@ ComponentLinter.universalComponentRules = [
             });
             return violations;
         }
+    },
+    {
+        name: 'utilities-valid-properties',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const validProperties = new Set(['rv', 'rq', 'md', 'ai']);
+            (0, traverse_1.default)(ast, {
+                MemberExpression(path) {
+                    // Check for utilities.* access
+                    if (t.isIdentifier(path.node.object) && path.node.object.name === 'utilities') {
+                        if (t.isIdentifier(path.node.property)) {
+                            const propName = path.node.property.name;
+                            // Check if it's a valid property
+                            if (!validProperties.has(propName)) {
+                                violations.push({
+                                    rule: 'utilities-valid-properties',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid utilities property '${propName}'. Valid properties are: rv (RunView), rq (RunQuery), md (Metadata), ai (AI Tools)`,
+                                    code: `utilities.${propName}`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'utilities-runview-methods',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const validMethods = new Set(['RunView', 'RunViews']);
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    // Check for utilities.rv.* method calls
+                    if (t.isMemberExpression(path.node.callee)) {
+                        const callee = path.node.callee;
+                        // Check if it's utilities.rv.methodName()
+                        if (t.isMemberExpression(callee.object) &&
+                            t.isIdentifier(callee.object.object) &&
+                            callee.object.object.name === 'utilities' &&
+                            t.isIdentifier(callee.object.property) &&
+                            callee.object.property.name === 'rv' &&
+                            t.isIdentifier(callee.property)) {
+                            const methodName = callee.property.name;
+                            if (!validMethods.has(methodName)) {
+                                violations.push({
+                                    rule: 'utilities-runview-methods',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid method '${methodName}' on utilities.rv. Valid methods are: RunView, RunViews`,
+                                    code: `utilities.rv.${methodName}()`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'utilities-runquery-methods',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const validMethods = new Set(['RunQuery']);
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    // Check for utilities.rq.* method calls
+                    if (t.isMemberExpression(path.node.callee)) {
+                        const callee = path.node.callee;
+                        // Check if it's utilities.rq.methodName()
+                        if (t.isMemberExpression(callee.object) &&
+                            t.isIdentifier(callee.object.object) &&
+                            callee.object.object.name === 'utilities' &&
+                            t.isIdentifier(callee.object.property) &&
+                            callee.object.property.name === 'rq' &&
+                            t.isIdentifier(callee.property)) {
+                            const methodName = callee.property.name;
+                            if (!validMethods.has(methodName)) {
+                                violations.push({
+                                    rule: 'utilities-runquery-methods',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid method '${methodName}' on utilities.rq. Valid method is: RunQuery`,
+                                    code: `utilities.rq.${methodName}()`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'utilities-metadata-methods',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const validMethods = new Set(['GetEntityObject']);
+            const validProperties = new Set(['Entities']);
+            (0, traverse_1.default)(ast, {
+                // Check for method calls
+                CallExpression(path) {
+                    // Check for utilities.md.* method calls
+                    if (t.isMemberExpression(path.node.callee)) {
+                        const callee = path.node.callee;
+                        // Check if it's utilities.md.methodName()
+                        if (t.isMemberExpression(callee.object) &&
+                            t.isIdentifier(callee.object.object) &&
+                            callee.object.object.name === 'utilities' &&
+                            t.isIdentifier(callee.object.property) &&
+                            callee.object.property.name === 'md' &&
+                            t.isIdentifier(callee.property)) {
+                            const methodName = callee.property.name;
+                            if (!validMethods.has(methodName)) {
+                                violations.push({
+                                    rule: 'utilities-metadata-methods',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid method '${methodName}' on utilities.md. Valid methods are: GetEntityObject. Valid properties are: Entities`,
+                                    code: `utilities.md.${methodName}()`
+                                });
+                            }
+                        }
+                    }
+                },
+                // Check for property access (non-call expressions)
+                MemberExpression(path) {
+                    // Skip if this is part of a call expression (handled above)
+                    if (t.isCallExpression(path.parent) && path.parent.callee === path.node) {
+                        return;
+                    }
+                    // Check if it's utilities.md.propertyName
+                    if (t.isMemberExpression(path.node.object) &&
+                        t.isIdentifier(path.node.object.object) &&
+                        path.node.object.object.name === 'utilities' &&
+                        t.isIdentifier(path.node.object.property) &&
+                        path.node.object.property.name === 'md' &&
+                        t.isIdentifier(path.node.property)) {
+                        const propName = path.node.property.name;
+                        // Check if it's accessing a valid property or trying to access an invalid one
+                        if (!validProperties.has(propName) && !validMethods.has(propName)) {
+                            violations.push({
+                                rule: 'utilities-metadata-methods',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Invalid property '${propName}' on utilities.md. Valid methods are: GetEntityObject. Valid properties are: Entities`,
+                                code: `utilities.md.${propName}`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'utilities-ai-methods',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const validMethods = new Set(['ExecutePrompt', 'EmbedText']);
+            const validProperties = new Set(['VectorService']);
+            (0, traverse_1.default)(ast, {
+                // Check for method calls
+                CallExpression(path) {
+                    // Check for utilities.ai.* method calls
+                    if (t.isMemberExpression(path.node.callee)) {
+                        const callee = path.node.callee;
+                        // Check if it's utilities.ai.methodName()
+                        if (t.isMemberExpression(callee.object) &&
+                            t.isIdentifier(callee.object.object) &&
+                            callee.object.object.name === 'utilities' &&
+                            t.isIdentifier(callee.object.property) &&
+                            callee.object.property.name === 'ai' &&
+                            t.isIdentifier(callee.property)) {
+                            const methodName = callee.property.name;
+                            if (!validMethods.has(methodName)) {
+                                violations.push({
+                                    rule: 'utilities-ai-methods',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid method '${methodName}' on utilities.ai. Valid methods are: ExecutePrompt, EmbedText. Valid property: VectorService`,
+                                    code: `utilities.ai.${methodName}()`
+                                });
+                            }
+                        }
+                    }
+                },
+                // Check for property access (VectorService)
+                MemberExpression(path) {
+                    // Skip if this is part of a call expression (handled above)
+                    if (t.isCallExpression(path.parent)) {
+                        return;
+                    }
+                    // Check if it's utilities.ai.propertyName
+                    if (t.isMemberExpression(path.node.object) &&
+                        t.isIdentifier(path.node.object.object) &&
+                        path.node.object.object.name === 'utilities' &&
+                        t.isIdentifier(path.node.object.property) &&
+                        path.node.object.property.name === 'ai' &&
+                        t.isIdentifier(path.node.property)) {
+                        const propName = path.node.property.name;
+                        // Check if it's a valid property or method (methods might be referenced without calling)
+                        if (!validProperties.has(propName) && !validMethods.has(propName)) {
+                            violations.push({
+                                rule: 'utilities-ai-properties',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Invalid property '${propName}' on utilities.ai. Valid methods are: ExecutePrompt, EmbedText. Valid property: VectorService`,
+                                code: `utilities.ai.${propName}`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'utilities-no-direct-instantiation',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const restrictedClasses = new Map([
+                ['RunView', 'utilities.rv'],
+                ['RunQuery', 'utilities.rq'],
+                ['Metadata', 'utilities.md'],
+                ['SimpleVectorService', 'utilities.ai.VectorService']
+            ]);
+            (0, traverse_1.default)(ast, {
+                NewExpression(path) {
+                    // Check if instantiating a restricted class
+                    if (t.isIdentifier(path.node.callee)) {
+                        const className = path.node.callee.name;
+                        if (restrictedClasses.has(className)) {
+                            const utilityPath = restrictedClasses.get(className);
+                            violations.push({
+                                rule: 'utilities-no-direct-instantiation',
+                                severity: 'high',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Don't instantiate ${className} directly. Use ${utilityPath} instead which is provided in the component's utilities parameter.`,
+                                code: `new ${className}()`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'unsafe-formatting-methods',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec, options) => {
+            const violations = [];
+            // Common formatting methods that can fail on null/undefined
+            const formattingMethods = new Set([
+                // Number methods
+                'toFixed', 'toPrecision', 'toExponential',
+                // Conversion methods
+                'toLocaleString', 'toString',
+                // String methods
+                'toLowerCase', 'toUpperCase', 'trim',
+                'split', 'slice', 'substring', 'substr',
+                'charAt', 'charCodeAt', 'indexOf', 'lastIndexOf',
+                'padStart', 'padEnd', 'repeat', 'replace'
+            ]);
+            const checkFieldNullability = (propertyName) => {
+                // Step 1: Check if componentSpec has data requirements and utilities are available
+                if (!componentSpec?.dataRequirements?.entities || !options?.utilities?.md?.Entities) {
+                    return { found: false, nullable: false };
+                }
+                try {
+                    // Step 2: Iterate through only the entities defined in dataRequirements
+                    for (const dataReqEntity of componentSpec.dataRequirements.entities) {
+                        const entityName = dataReqEntity.name; // e.g., "AI Prompt Runs"
+                        // Step 3: Find this entity in the full metadata (case insensitive)
+                        // Use proper typing - we know Entities is an array of EntityInfo objects
+                        const fullEntity = options.utilities.md?.Entities.find((e) => e.Name && e.Name.toLowerCase() === entityName.toLowerCase());
+                        if (fullEntity && fullEntity.Fields && Array.isArray(fullEntity.Fields)) {
+                            // Step 4: Look for the field in this specific entity (case insensitive)
+                            const field = fullEntity.Fields.find((f) => f.Name && f.Name.trim().toLowerCase() === propertyName.trim().toLowerCase());
+                            if (field) {
+                                // Field found - check if it's nullable
+                                // In MJ, AllowsNull is a boolean property
+                                return {
+                                    found: true,
+                                    nullable: field.AllowsNull,
+                                    entityName: fullEntity.Name,
+                                    fieldName: field.Name
+                                };
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // If there's any error accessing metadata, fail gracefully
+                    console.warn('Error checking field nullability:', error);
+                }
+                return { found: false, nullable: false };
+            };
+            (0, traverse_1.default)(ast, {
+                // Check JSX expressions
+                JSXExpressionContainer(path) {
+                    const expr = path.node.expression;
+                    // Look for object.property.method() pattern
+                    if (t.isCallExpression(expr) &&
+                        t.isMemberExpression(expr.callee) &&
+                        t.isIdentifier(expr.callee.property)) {
+                        const methodName = expr.callee.property.name;
+                        // Check if it's a formatting method
+                        if (formattingMethods.has(methodName)) {
+                            const callee = expr.callee;
+                            // Check if the object being called on is also a member expression (x.y pattern)
+                            if (t.isMemberExpression(callee.object) &&
+                                t.isIdentifier(callee.object.property)) {
+                                const propertyName = callee.object.property.name;
+                                // Check if optional chaining is already used
+                                const hasOptionalChaining = callee.object.optional || callee.optional;
+                                // Check if there's a fallback (looking in parent for || or ??)
+                                let hasFallback = false;
+                                const parent = path.parent;
+                                const grandParent = path.parentPath?.parent;
+                                // Check if parent is a logical expression with fallback
+                                if (grandParent && t.isLogicalExpression(grandParent) &&
+                                    (grandParent.operator === '||' || grandParent.operator === '??')) {
+                                    hasFallback = true;
+                                }
+                                // Also check conditional expressions
+                                if (grandParent && t.isConditionalExpression(grandParent)) {
+                                    hasFallback = true;
+                                }
+                                if (!hasOptionalChaining && !hasFallback) {
+                                    // Check entity metadata for this field
+                                    const fieldInfo = checkFieldNullability(propertyName);
+                                    // Determine severity based on metadata
+                                    let severity = 'medium';
+                                    let message = `Unsafe formatting method '${methodName}()' called on '${propertyName}'. Consider using optional chaining.`;
+                                    if (fieldInfo.found) {
+                                        if (fieldInfo.nullable) {
+                                            severity = 'high';
+                                            message = `Field '${fieldInfo.fieldName}' from entity '${fieldInfo.entityName}' is nullable. Use optional chaining to prevent runtime errors when calling '${methodName}()'.`;
+                                        }
+                                        else {
+                                            // Keep medium severity but note it's non-nullable
+                                            message = `Field '${fieldInfo.fieldName}' from entity '${fieldInfo.entityName}' appears to be non-nullable, but consider using optional chaining for safety when calling '${methodName}()'.`;
+                                        }
+                                    }
+                                    // Get the object name for better error message
+                                    let objectName = '';
+                                    if (t.isIdentifier(callee.object.object)) {
+                                        objectName = callee.object.object.name;
+                                    }
+                                    violations.push({
+                                        rule: 'unsafe-formatting-methods',
+                                        severity: severity,
+                                        line: expr.loc?.start.line || 0,
+                                        column: expr.loc?.start.column || 0,
+                                        message: message,
+                                        code: `${objectName}.${propertyName}.${methodName}() → ${objectName}.${propertyName}?.${methodName}() ?? defaultValue`
+                                    });
+                                }
+                            }
+                        }
+                    }
+                },
+                // Also check template literals
+                TemplateLiteral(path) {
+                    for (const expr of path.node.expressions) {
+                        // Look for object.property.method() pattern in template expressions
+                        if (t.isCallExpression(expr) &&
+                            t.isMemberExpression(expr.callee) &&
+                            t.isIdentifier(expr.callee.property)) {
+                            const methodName = expr.callee.property.name;
+                            // Check if it's a formatting method
+                            if (formattingMethods.has(methodName)) {
+                                const callee = expr.callee;
+                                // Check if the object being called on is also a member expression (x.y pattern)
+                                if (t.isMemberExpression(callee.object) &&
+                                    t.isIdentifier(callee.object.property)) {
+                                    const propertyName = callee.object.property.name;
+                                    // Check if optional chaining is already used
+                                    const hasOptionalChaining = callee.object.optional || callee.optional;
+                                    if (!hasOptionalChaining) {
+                                        // Check entity metadata for this field
+                                        const fieldInfo = checkFieldNullability(propertyName);
+                                        // Determine severity based on metadata
+                                        let severity = 'medium';
+                                        let message = `Unsafe formatting method '${methodName}()' called on '${propertyName}' in template literal. Consider using optional chaining.`;
+                                        if (fieldInfo.found) {
+                                            if (fieldInfo.nullable) {
+                                                severity = 'high';
+                                                message = `Field '${propertyName}' is nullable in entity metadata. Use optional chaining to prevent runtime errors when calling '${methodName}()' in template literal.`;
+                                            }
+                                            else {
+                                                // Keep medium severity but note it's non-nullable
+                                                message = `Field '${propertyName}' appears to be non-nullable, but consider using optional chaining for safety when calling '${methodName}()' in template literal.`;
+                                            }
+                                        }
+                                        // Get the object name for better error message
+                                        let objectName = '';
+                                        if (t.isIdentifier(callee.object.object)) {
+                                            objectName = callee.object.object.name;
+                                        }
+                                        violations.push({
+                                            rule: 'unsafe-formatting-methods',
+                                            severity: severity,
+                                            line: expr.loc?.start.line || 0,
+                                            column: expr.loc?.start.column || 0,
+                                            message: message,
+                                            code: `\${${objectName}.${propertyName}.${methodName}()} → \${${objectName}.${propertyName}?.${methodName}() ?? defaultValue}`
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
     }
 ];
 //# sourceMappingURL=component-linter.js.map