@sailshq/language-server 0.2.1 → 0.2.3

package/completions/model-attributes-completion.js

@@ -18,18 +18,12 @@ module.exports = function modelAttributesCompletion(
   const criteriaMatch = before.match(
     /(?:sails\.models\.([A-Za-z_$][\w$]*)|([A-Za-z_$][\w$]*))\s*\.\w+\s*\(\s*\{[^}]*([a-zA-Z0-9_]*)?$/
   )
-  const selectStringMatch = before.match(
-    /(?:select|omit|sort)\s*:\s*['"]([a-zA-Z0-9_]*)?$/
-  )
-  const selectArrayMatch = before.match(
+  const sortStringMatch = before.match(/sort\s*:\s*['"]([a-zA-Z0-9_]*)?$/)
+  const criteriaOptionsArrayMatch = before.match(
     /(?:select|omit|sort)\s*:\s*\[\s*['"]([a-zA-Z0-9_]*)?$/
   )
-  const populateStringMatch = before.match(
-    /populate\s*:\s*['"]([a-zA-Z0-9_]*)?$/
-  )
-  const sortStringMatch = before.match(/sort\s*:\s*['"]([a-zA-Z0-9_]*)?$/)
-  const sortArrayStringMatch = before.match(
-    /sort\s*:\s*\[\s*[^\{\]]*['"]([a-zA-Z0-9_]*)?$/
+  const popuplateMethodMatch = before.match(
+    /\.populate\s*\(\s*['"]([a-zA-Z0-9_]*)?$/
   )
   const sortArrayObjectMatch = before.match(
     /sort\s*:\s*\[\s*\{\s*([a-zA-Z0-9_]*)?$/
@@ -44,7 +38,7 @@ module.exports = function modelAttributesCompletion(
   // Detect if we are inside a .select([]), .omit([]), .sort([]), etc. as a method call (e.g. User.find().select([]))
   // This matches e.g. .select(['foo', '']) or .omit(["bar", '']) or .select('foo')
   const chainableDirectCallMatch = before.match(
-    /\.(select|omit|sort|populate|where)\s*\(\s*\[?\s*['"]?([a-zA-Z0-9_]*)?$/
+    /\.(select|omit|sort|populate|where)\s*\(\s*\[.*(?:,|\[)?\s*['"`]([a-zA-Z0-9_]*)?$/
   )
 
   // Also allow completions in .where({ ... }) chainable method call context
@@ -56,41 +50,52 @@ module.exports = function modelAttributesCompletion(
     /([A-Za-z_$][\w$]*)\s*\.where\s*\(\s*\{[^}]*([a-zA-Z0-9_]*)?$/
   )
 
+  // Support chained .where({ ... }) completions ---
+  // Try to infer model name from chained calls like User.find().where({ ... })
+  const chainedWhereMatch = before.match(
+    /([A-Za-z_$][\w$]*)\s*\.[\w$]+\s*\(.*?\)\s*\.where\s*\(\s*\{[^}]*([a-zA-Z0-9_]*)?$/
+  )
+
   // Only suppress completions after a colon (:) in object literals for static methods,
   // but always allow completions in .select(['']), .omit(['']), .sort(['']), .where({}), etc.
   const inChainableString =
-    selectStringMatch ||
-    selectArrayMatch ||
+    criteriaOptionsArrayMatch ||
     sortStringMatch ||
-    sortArrayStringMatch ||
     sortArrayObjectMatch ||
-    populateStringMatch ||
+    popuplateMethodMatch ||
     isInChainableMethodCall ||
     isInWhereMethodCall ||
     !!chainableDirectCallMatch
 
   // Suppress completions after a colon only if NOT in a chainable string/array context
-  if (!inChainableString) {
-    const lines = before.split('\n')
-    const line = lines[lines.length - 1]
-    const beforeCursor = line.slice(0, position.character)
-    // If the last non-whitespace character before the cursor is a colon, suppress completion
-    // (but allow after comma, or at start of line/object)
-    const lastColon = beforeCursor.lastIndexOf(':')
-    const lastComma = beforeCursor.lastIndexOf(',')
-    if (lastColon > lastComma && lastColon > beforeCursor.lastIndexOf('{')) {
-      // Check if we are inside a string (e.g. after a colon and inside quotes)
-      // If so, suppress completion
-      const quoteBefore = beforeCursor.lastIndexOf("'")
-      const dquoteBefore = beforeCursor.lastIndexOf('"')
-      if (
-        (quoteBefore > lastColon && quoteBefore > lastComma) ||
-        (dquoteBefore > lastColon && dquoteBefore > lastComma)
-      ) {
+  // Also suppress completions after colon in .where({ ... }) context, unless after a comma or at start
+  // FIX: Do not run this suppression logic at all if we are in a select/omit/sort array (object property form)
+  if (!criteriaOptionsArrayMatch) {
+    if (
+      !inChainableString ||
+      ((isInWhereMethodCall || chainedWhereMatch) && !criteriaOptionsArrayMatch)
+    ) {
+      const lines = before.split('\n')
+      const line = lines[lines.length - 1]
+      const beforeCursor = line.slice(0, position.character)
+      // If the last non-whitespace character before the cursor is a colon, suppress completion
+      // (but allow after comma, or at start of line/object)
+      const lastColon = beforeCursor.lastIndexOf(':')
+      const lastComma = beforeCursor.lastIndexOf(',')
+      if (lastColon > lastComma && lastColon > beforeCursor.lastIndexOf('{')) {
+        // Check if we are inside a string (e.g. after a colon and inside quotes)
+        // If so, suppress completion
+        const quoteBefore = beforeCursor.lastIndexOf("'")
+        const dquoteBefore = beforeCursor.lastIndexOf('"')
+        if (
+          (quoteBefore > lastColon && quoteBefore > lastComma) ||
+          (dquoteBefore > lastColon && dquoteBefore > lastComma)
+        ) {
+          return []
+        }
+        // Otherwise, suppress completion after colon
         return []
       }
-      // Otherwise, suppress completion after colon
-      return []
     }
   }
 
@@ -114,23 +119,35 @@ module.exports = function modelAttributesCompletion(
     return last[1] || last[2] || null
   }
 
+  // Determine the current Sails.js model context and attribute prefix for completions
+  // by matching the code before the cursor against various Sails.js query patterns.
+  // This enables context-aware attribute completions for all supported query forms.
   if (criteriaMatch) {
     modelName = criteriaMatch[1] || criteriaMatch[2]
     prefix = criteriaMatch[3] || ''
-  } else if (selectStringMatch || selectArrayMatch) {
+  } else if (criteriaOptionsArrayMatch) {
     modelName = inferModelName(before)
-    prefix = (selectStringMatch || selectArrayMatch)[1] || ''
-  } else if (populateStringMatch) {
+    prefix = criteriaOptionsArrayMatch[1] || ''
+  } else if (popuplateMethodMatch) {
     isPopulate = true
     modelName = inferModelName(before)
-    prefix = populateStringMatch[1] || ''
-  } else if (sortStringMatch || sortArrayStringMatch || sortArrayObjectMatch) {
+    prefix = popuplateMethodMatch[1] || ''
+  } else if (
+    sortStringMatch ||
+    criteriaOptionsArrayMatch ||
+    sortArrayObjectMatch
+  ) {
     modelName = inferModelName(before)
     prefix =
-      (sortStringMatch || sortArrayStringMatch || sortArrayObjectMatch)[1] || ''
+      (sortStringMatch ||
+        criteriaOptionsArrayMatch ||
+        sortArrayObjectMatch)[1] || ''
   } else if (whereMethodCallMatch) {
     modelName = whereMethodCallMatch[1]
     prefix = whereMethodCallMatch[2] || ''
+  } else if (chainedWhereMatch) {
+    modelName = chainedWhereMatch[1]
+    prefix = chainedWhereMatch[2] || ''
   } else if (chainableDirectCallMatch) {
     modelName = inferModelName(before)
     prefix = chainableDirectCallMatch[2] || ''
@@ -166,6 +183,59 @@ module.exports = function modelAttributesCompletion(
     }
   }
 
+  // Remove already-used attributes for both object and array/chainable forms
+  // Collect all used attributes from any select/omit/sort array in object or chainable form up to the cursor
+  const allArrayRegex =
+    /(select|omit|sort)\s*:\s*\[([^\]]*)\]|\.(select|omit|sort)\s*\(\s*\[([^\]]*)/g
+  let match
+  while ((match = allArrayRegex.exec(before)) !== null) {
+    const arrayContent = match[2] || match[4] || ''
+    const usedInArray = Array.from(
+      arrayContent.matchAll(/['"`]\s*([a-zA-Z0-9_]+)\s*['"`]/g)
+    ).map((m) => m[1])
+    usedInArray.forEach((attr) => usedProps.add(attr))
+  }
+
+  // Improved: Only trigger completions in object form select/omit/sort arrays when inside a string (between quotes)
+  if (criteriaOptionsArrayMatch) {
+    // Find the last '[' before the cursor
+    const arrayStart = before.lastIndexOf('[')
+    if (arrayStart !== -1) {
+      const arrayContent = before.slice(arrayStart, offset)
+      // Use the same logic as chainable: check for a quote before the cursor (inside a string)
+      const quoteMatch = arrayContent.match(/['"`]([^'"`]*)$/)
+      if (!quoteMatch) {
+        // Not inside a string, suppress completions
+        return []
+      }
+      // Also: filter out already-used attributes in this array
+      const usedInArray = Array.from(
+        arrayContent.matchAll(/['"`]\s*([a-zA-Z0-9_]+)\s*['"`]/g)
+      ).map((m) => m[1])
+      usedInArray.forEach((attr) => usedProps.add(attr))
+    }
+  }
+
+  if (chainableDirectCallMatch) {
+    // For array/chainable forms, parse the array up to the cursor and collect used attributes
+    const arrayMatch = before.match(/\[([^\]]*)$/)
+    if (arrayMatch) {
+      const arrayContent = arrayMatch[1]
+      // Fix: allow completions for any string in the array, not just the first
+      // Find the last quote and ensure the cursor is after it (inside a string)
+      const quoteMatch = arrayContent.match(/['"`][^'"`]*$/)
+      if (!quoteMatch) {
+        // Not inside a string, suppress completions
+        return []
+      }
+      // Also: filter out already-used attributes in this array
+      const usedInArray = Array.from(
+        arrayContent.matchAll(/['"`]\s*([a-zA-Z0-9_]+)\s*['"`]/g)
+      ).map((m) => m[1])
+      usedInArray.forEach((attr) => usedProps.add(attr))
+    }
+  }
+
   if (isPopulate) {
     attributes = Object.entries(model.attributes || {})
       .filter(([, def]) => def && (def.model || def.collection))
@@ -174,22 +244,25 @@ module.exports = function modelAttributesCompletion(
     attributes = Object.keys(model.attributes || {})
   }
 
-  return attributes
-    .filter((attr) => attr.startsWith(prefix))
-    .filter((attr) => !usedProps.has(attr))
-    .map((attr) => {
-      const attrDef = model.attributes && model.attributes[attr]
-      let type = attrDef && attrDef.type ? attrDef.type : ''
-      let required = attrDef && attrDef.required ? 'required' : 'optional'
-      let detail = type ? `${type} (${required})` : required
-      return {
-        label: attr,
-        kind: lsp.CompletionItemKind.Field,
-        detail,
-        documentation: `${modelName}.${attr}`,
-        sortText: attr,
-        filterText: attr,
-        insertText: attr
-      }
-    })
+  return Array.from(
+    new Set(
+      attributes
+        .filter((attr) => attr.toLowerCase().startsWith(prefix.toLowerCase()))
+        .filter((attr) => !usedProps.has(attr))
+    )
+  ).map((attr) => {
+    const attrDef = model.attributes && model.attributes[attr]
+    let type = attrDef && attrDef.type ? attrDef.type : ''
+    let required = attrDef && attrDef.required ? 'required' : 'optional'
+    let detail = type ? `${type} (${required})` : required
+    return {
+      label: attr,
+      kind: lsp.CompletionItemKind.Field,
+      detail,
+      documentation: `${modelName}.${attr}`,
+      sortText: attr,
+      filterText: attr,
+      insertText: attr
+    }
+  })
 }

package/completions/model-methods-completion.js

@@ -15,10 +15,10 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
   const staticCallMatch = before.match(
     /(?:sails\.models\.([A-Za-z_$][\w$]*)|([A-Za-z_$][\w$]*))\.\s*([a-zA-Z]*)?$/
   )
-  // Match chainable calls like User.find().<chainable> or User.find({...}).<chainable>
-  const chainableCallMatch = before.match(
-    /([A-Za-z_$][\w$]*)\.[a-zA-Z_]+\([^)]*\)\.\s*([a-zA-Z]*)?$/
-  )
+  // Match all chainable calls and get the last one for completion
+  const chainableCallMatches = [
+    ...before.matchAll(/([A-Za-z_$][\w$]*)\.[a-zA-Z_]+\([^)]*\)/g)
+  ]
 
   let modelName, prefix, methods
 
@@ -26,11 +26,15 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
   const models = typeMap.models || {}
   const modelKeys = Object.keys(models)
 
-  if (chainableCallMatch) {
-    modelName = chainableCallMatch[1]
-    prefix = chainableCallMatch[2] || ''
-    if (!modelName) return []
-    const foundKey = modelKeys.find(
+  if (chainableCallMatches.length > 0) {
+    // Use the last chainable call in the chain
+    const lastMatch = chainableCallMatches[chainableCallMatches.length - 1]
+    modelName = lastMatch[1]
+    // Get the prefix after the last dot (if user is typing e.g. .select)
+    const afterLastChain = before.slice(lastMatch.index + lastMatch[0].length)
+    const prefixMatch = afterLastChain.match(/\.\s*([a-zA-Z]*)?$/)
+    prefix = (prefixMatch && prefixMatch[1]) || ''
+    const foundKey = Object.keys(models).find(
       (k) => k.toLowerCase() === modelName.toLowerCase()
     )
     methods = foundKey ? models[foundKey].chainableMethods || [] : []
@@ -52,7 +56,7 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
       let insertText = method.name + '($0)'
       // For chainable .select or .omit, insert ([''])
       if (
-        chainableCallMatch &&
+        chainableCallMatches.length > 0 &&
         (method.name === 'select' || method.name === 'omit')
       ) {
         insertText = method.name + '([$0])'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailshq/language-server",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Language Server Protocol server for Sails Language Service",
   "homepage": "https://sailjs.com",
   "repository": {
@@ -27,5 +27,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@sailshq/language-server": "^0.2.1"
   }
 }

package/validators/validate-model-attribute-exist.js

@@ -34,32 +34,236 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
     })
     walk.simple(ast, {
       CallExpression(node) {
-        if (
-          node.callee &&
-          node.callee.type === 'MemberExpression' &&
-          node.arguments &&
-          node.arguments.length > 0 &&
-          node.arguments[0].type === 'ObjectExpression'
-        ) {
+        if (node.callee && node.callee.type === 'MemberExpression') {
           const method = node.callee.property.name
-          const modelName = node.callee.object.name
-          // Only check for Waterline methods
+          // --- Robust model name extraction for ALL method calls (including chainable) ---
+          let effectiveModelName = undefined
+          let obj = node.callee.object
+          while (obj) {
+            if (obj.type === 'Identifier') {
+              effectiveModelName = obj.name
+              break
+            } else if (
+              obj.type === 'CallExpression' &&
+              obj.callee &&
+              obj.callee.type === 'MemberExpression'
+            ) {
+              obj = obj.callee.object
+            } else {
+              break
+            }
+          }
+          const model = getModelByName(effectiveModelName)
+          if (!model) return
+
+          // Only validate chainable methods that are select, omit, sort, or populate
+          const allowedChainable = ['select', 'omit', 'sort', 'populate']
+
+          // --- Ignore validation for arguments to non-model chainable methods like .intercept ---
+          // If the current method is NOT a model method or allowedChainable, skip validation for its arguments
+          const modelMethods = [
+            'create',
+            'createEach',
+            'count',
+            'find',
+            'findOne',
+            'update',
+            'destroy',
+            'where',
+            'findOrCreate',
+            'sum',
+            ...allowedChainable
+          ]
+          if (!modelMethods.includes(method)) {
+            // This is a non-model method (e.g., intercept, using, etc.), skip validation for its arguments
+            return
+          }
+
+          // handle createEach array of objects
+          if (
+            method === 'createEach' &&
+            node.arguments[0] &&
+            node.arguments[0].type === 'ArrayExpression'
+          ) {
+            for (const el of node.arguments[0].elements) {
+              if (!el || el.type !== 'ObjectExpression') continue
+              for (const prop of el.properties) {
+                const attribute = prop.key && (prop.key.name || prop.key.value)
+                if (
+                  !model.attributes ||
+                  !Object.prototype.hasOwnProperty.call(
+                    model.attributes,
+                    attribute
+                  )
+                ) {
+                  diagnostics.push(
+                    lsp.Diagnostic.create(
+                      lsp.Range.create(
+                        document.positionAt(prop.key.start),
+                        document.positionAt(prop.key.end)
+                      ),
+                      `'${attribute}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                      lsp.DiagnosticSeverity.Error,
+                      'sails-lsp'
+                    )
+                  )
+                }
+              }
+            }
+            return
+          }
+
+          // Validate attributes in chained .where({ ... }) calls
           if (
-            [
-              'create',
-              'createEach',
-              'count',
-              'find',
-              'findOne',
-              'update',
-              'destroy',
-              'where',
-              'findOrCreate',
-              'sum'
-            ].includes(method)
+            method === 'where' &&
+            node.arguments[0] &&
+            node.arguments[0].type === 'ObjectExpression'
           ) {
-            const model = getModelByName(modelName)
-            if (!model) return
+            for (const prop of node.arguments[0].properties) {
+              if (!prop.key) continue
+              const whereAttr = prop.key.name || prop.key.value
+              if (
+                !model.attributes ||
+                !Object.prototype.hasOwnProperty.call(
+                  model.attributes,
+                  whereAttr
+                )
+              ) {
+                diagnostics.push(
+                  lsp.Diagnostic.create(
+                    lsp.Range.create(
+                      document.positionAt(prop.key.start),
+                      document.positionAt(prop.key.end)
+                    ),
+                    `'${whereAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                    lsp.DiagnosticSeverity.Error,
+                    'sails-lsp'
+                  )
+                )
+              }
+            }
+            return
+          }
+
+          // --- Unified validation for .select([]), .omit([]), .sort([]), .populate([]) chainable calls only ---
+          if (
+            allowedChainable.includes(method) &&
+            node.arguments[0] &&
+            node.arguments[0].type === 'ArrayExpression'
+          ) {
+            for (const el of node.arguments[0].elements) {
+              if (!el) continue
+              let arrAttr = undefined
+              if (el.type === 'Literal' || el.type === 'StringLiteral') {
+                arrAttr = el.value
+              } else if (
+                el.type === 'TemplateLiteral' &&
+                el.expressions.length === 0
+              ) {
+                arrAttr = el.quasis[0].value.cooked
+              } else if (el.type === 'ObjectExpression' && method === 'sort') {
+                // For sort([{ foo: 1 }])
+                for (const sortProp of el.properties) {
+                  if (!sortProp.key) continue
+                  const sortAttr = sortProp.key.name || sortProp.key.value
+                  if (
+                    !model.attributes ||
+                    !Object.prototype.hasOwnProperty.call(
+                      model.attributes,
+                      sortAttr
+                    )
+                  ) {
+                    diagnostics.push(
+                      lsp.Diagnostic.create(
+                        lsp.Range.create(
+                          document.positionAt(sortProp.key.start),
+                          document.positionAt(sortProp.key.end)
+                        ),
+                        `'${sortAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                        lsp.DiagnosticSeverity.Error,
+                        'sails-lsp'
+                      )
+                    )
+                  }
+                }
+                continue
+              }
+              if (arrAttr !== undefined) {
+                // For sort, allow 'foo ASC' or 'foo DESC'
+                let checkAttr = arrAttr
+                if (method === 'sort' && typeof arrAttr === 'string') {
+                  checkAttr = arrAttr.split(' ')[0]
+                }
+                if (
+                  !checkAttr ||
+                  typeof checkAttr !== 'string' ||
+                  checkAttr.trim() === ''
+                ) {
+                  diagnostics.push(
+                    lsp.Diagnostic.create(
+                      lsp.Range.create(
+                        document.positionAt(el.start),
+                        document.positionAt(el.end)
+                      ),
+                      `Empty or invalid attribute in .${method}() for model '${effectiveModelName}'.`,
+                      lsp.DiagnosticSeverity.Error,
+                      'sails-lsp'
+                    )
+                  )
+                  continue
+                }
+                if (
+                  !model.attributes ||
+                  !Object.prototype.hasOwnProperty.call(
+                    model.attributes,
+                    checkAttr
+                  )
+                ) {
+                  diagnostics.push(
+                    lsp.Diagnostic.create(
+                      lsp.Range.create(
+                        document.positionAt(el.start),
+                        document.positionAt(el.end)
+                      ),
+                      `'${checkAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                      lsp.DiagnosticSeverity.Error,
+                      'sails-lsp'
+                    )
+                  )
+                }
+              }
+            }
+            // Do NOT return here; allow walker to continue to chained calls
+          }
+
+          // Validate attributes in .find({ ... }) and similar methods
+          if (
+            node.arguments[0] &&
+            node.arguments[0].type === 'ObjectExpression'
+          ) {
+            // Only validate if this is a top-level model method call, not an argument to another method (e.g., intercept)
+            // Check that the callee is a direct property of an Identifier (the model), not a nested CallExpression
+            let isTopLevelModelCall = false
+            let calleeObj = node.callee.object
+            if (calleeObj && calleeObj.type === 'Identifier') {
+              isTopLevelModelCall = true
+            } else if (calleeObj && calleeObj.type === 'CallExpression') {
+              // If the parent is a CallExpression, but the root is an Identifier, still allow
+              let root = calleeObj
+              while (
+                root &&
+                root.type === 'CallExpression' &&
+                root.callee &&
+                root.callee.type === 'MemberExpression'
+              ) {
+                root = root.callee.object
+              }
+              if (root && root.type === 'Identifier') {
+                isTopLevelModelCall = true
+              }
+            }
+            // If this is an argument to a non-model method (e.g., intercept), skip validation
+            if (!isTopLevelModelCall) return
             for (const prop of node.arguments[0].properties) {
               const attribute = prop.key && (prop.key.name || prop.key.value)
               const queryOptionKeys = [
@@ -80,7 +284,33 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                 'distinct',
                 'meta'
               ]
-              // --- FINAL FIX: treat 'where' exactly like 'sort', 'select', 'omit' for non-create methods ---
+              // For non-create methods, validate all top-level keys except query option keys
+              if (
+                method !== 'create' &&
+                method !== 'createEach' &&
+                !queryOptionKeys.includes(attribute)
+              ) {
+                if (
+                  !model.attributes ||
+                  !Object.prototype.hasOwnProperty.call(
+                    model.attributes,
+                    attribute
+                  )
+                ) {
+                  diagnostics.push(
+                    lsp.Diagnostic.create(
+                      lsp.Range.create(
+                        document.positionAt(prop.key.start),
+                        document.positionAt(prop.key.end)
+                      ),
+                      `'${attribute}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                      lsp.DiagnosticSeverity.Error,
+                      'sails-lsp'
+                    )
+                  )
+                }
+                continue
+              }
               if (
                 method !== 'create' &&
                 method !== 'createEach' &&
@@ -107,7 +337,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                             document.positionAt(whereProp.key.start),
                             document.positionAt(whereProp.key.end)
                           ),
-                          `'${whereAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                          `'${whereAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                           lsp.DiagnosticSeverity.Error,
                           'sails-lsp'
                         )
@@ -138,7 +368,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                               document.positionAt(el.start),
                               document.positionAt(el.end)
                             ),
-                            `'${arrAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                            `'${arrAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                             lsp.DiagnosticSeverity.Error,
                             'sails-lsp'
                           )
@@ -169,7 +399,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                             document.positionAt(prop.value.start),
                             document.positionAt(prop.value.end)
                           ),
-                          `'${sortAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                          `'${sortAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                           lsp.DiagnosticSeverity.Error,
                           'sails-lsp'
                         )
@@ -197,7 +427,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                                   document.positionAt(sortProp.key.start),
                                   document.positionAt(sortProp.key.end)
                                 ),
-                                `'${sortAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                                `'${sortAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                                 lsp.DiagnosticSeverity.Error,
                                 'sails-lsp'
                               )
@@ -224,7 +454,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                                 document.positionAt(el.start),
                                 document.positionAt(el.end)
                               ),
-                              `'${sortAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                              `'${sortAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                               lsp.DiagnosticSeverity.Error,
                               'sails-lsp'
                             )
@@ -250,7 +480,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                               document.positionAt(sortProp.key.start),
                               document.positionAt(sortProp.key.end)
                             ),
-                            `'${sortAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                            `'${sortAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                             lsp.DiagnosticSeverity.Error,
                             'sails-lsp'
                           )
@@ -263,7 +493,6 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                 // For all other query option keys, skip validation
                 continue
               }
-              // --- END ROBUST FIX ---
               // Only validate top-level for create/createEach
               if (
                 (method === 'create' || method === 'createEach') &&
@@ -279,7 +508,7 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                       document.positionAt(prop.key.start),
                       document.positionAt(prop.key.end)
                     ),
-                    `'${attribute}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                    `'${attribute}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
                     lsp.DiagnosticSeverity.Error,
                     'sails-lsp'
                   )