@sailshq/language-server 0.3.2 → 0.4.0

package/SailsParser.js

@@ -60,30 +60,68 @@ class SailsParser {
     const actionsRoot = path.join(this.rootDir, 'api', 'controllers')
     const content = await this.#readFile(routesPath)
     const routes = {}
+    const actionsToParse = []
 
-    const regex = /['"]([^'"]+)['"]\s*:\s*['"]([^'"]+)['"]/g
-    let match
-    while ((match = regex.exec(content))) {
-      const route = match[1]
-      const actionName = match[2]
+    try {
+      const ast = acorn.parse(content, {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      })
 
-      // Skip redirects and external URLs
-      // Routes that start with '/' or contain '://' are redirects, not actions
-      if (actionName.startsWith('/') || actionName.includes('://')) {
-        continue
-      }
+      walk.simple(ast, {
+        Property(node) {
+          const routePattern = node.key?.value || node.key?.name
+          if (!routePattern) return
 
-      const filePath = path.join(actionsRoot, ...actionName.split('/')) + '.js'
+          let actionName = null
 
-      const actionInfo = await this.#parseAction(filePath)
+          if (
+            node.value?.type === 'Literal' &&
+            typeof node.value.value === 'string'
+          ) {
+            actionName = node.value.value
+          } else if (
+            node.value?.type === 'ObjectExpression' &&
+            node.value.properties
+          ) {
+            for (const prop of node.value.properties) {
+              if (
+                prop.type === 'Property' &&
+                (prop.key?.name === 'action' || prop.key?.value === 'action') &&
+                prop.value?.type === 'Literal' &&
+                typeof prop.value.value === 'string'
+              ) {
+                actionName = prop.value.value
+                break
+              }
+            }
+          }
 
-      routes[route] = {
-        action: {
-          name: actionName,
-          path: filePath,
-          ...actionInfo
+          if (
+            actionName &&
+            !actionName.startsWith('/') &&
+            !actionName.includes('://')
+          ) {
+            actionsToParse.push({ routePattern, actionName })
+          }
+        }
+      })
+
+      for (const { routePattern, actionName } of actionsToParse) {
+        const filePath =
+          path.join(actionsRoot, ...actionName.split('/')) + '.js'
+        const actionInfo = await this.#parseAction(filePath)
+
+        routes[routePattern] = {
+          action: {
+            name: actionName,
+            path: filePath,
+            ...actionInfo
+          }
         }
       }
+    } catch (error) {
+      console.error('Error parsing routes:', error)
     }
 
     return routes

package/completions/model-attribute-props-completion.js

@@ -21,30 +21,31 @@ module.exports = function modelAttributePropsCompletion(
   const insideAttributes = /attributes\s*:\s*{([\s\S]*)$/.exec(before)
   if (!insideAttributes) return []
 
-  // Use a stack to track braces and find if we're inside a property block
-  let braceStack = []
-  let insideProperty = false
-  for (let i = lines.length - 1; i >= 0; i--) {
+  // Count nesting depth from attributes: { to current position
+  // We want depth > 1 (inside a property) not depth === 1 (top level of attributes)
+  let depth = 0
+  let foundAttributesBlock = false
+
+  for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
-    for (let j = line.length - 1; j >= 0; j--) {
-      if (line[j] === '}') braceStack.push('}')
-      if (line[j] === '{') {
-        if (braceStack.length > 0) {
-          braceStack.pop()
-        } else {
-          const propMatch = lines[i]
-            .slice(0, j + 1)
-            .match(/([a-zA-Z0-9_]+)\s*:\s*{$/)
-          if (propMatch) insideProperty = true
-          break
-        }
+
+    if (/attributes\s*:\s*{/.test(line)) {
+      foundAttributesBlock = true
+      depth = 1
+      continue
+    }
+
+    if (foundAttributesBlock) {
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') depth++
+        if (line[j] === '}') depth--
       }
     }
-    if (insideProperty) break
-    if (/^\s*attributes\s*:\s*{/.test(line)) break
   }
 
-  if (!insideProperty) return []
+  // Only provide completions if we're nested inside a property (depth > 1)
+  // depth === 1 means we're at the top level of attributes: {}
+  if (depth <= 1) return []
 
   return typeMap.modelAttributeProps.map(({ label, detail }) => ({
     label,

package/completions/model-attributes-completion.js

@@ -1,4 +1,22 @@
 const lsp = require('vscode-languageserver/node')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
+
+const WATERLINE_MODIFIERS = ['or', 'and', 'not']
+const WATERLINE_OPERATORS = [
+  '<',
+  '<=',
+  '>',
+  '>=',
+  '!=',
+  'nin',
+  'in',
+  'contains',
+  'startsWith',
+  'endsWith',
+  'like',
+  '!'
+]
 
 module.exports = function modelAttributesCompletion(
   document,
@@ -15,6 +33,31 @@ module.exports = function modelAttributesCompletion(
   const offset = document.offsetAt(position)
   const before = text.substring(0, offset)
 
+  // Don't provide completions after a chainable method call dot (e.g., User.find().catch|)
+  // This context should show chainable methods, not attributes
+  const afterChainableDot = /\.[a-zA-Z_]+\([^)]*\)\.\s*[a-zA-Z]*$/
+  if (afterChainableDot.test(before)) {
+    return []
+  }
+
+  // Don't provide completions inside operator value arrays like { in: ['val1', ''] }
+  // Check if we're inside an array that follows an operator
+  const insideOperatorArray = before.match(
+    /(in|nin|contains|startsWith|endsWith|like)\s*:\s*\[[^\]]*$/
+  )
+  if (insideOperatorArray) {
+    return []
+  }
+
+  // Don't provide completions inside operator objects like { contains: '...', | }
+  // Check if we're after a comma inside an object that has operator keys
+  const insideOperatorObject = before.match(
+    /\{[^}]*(contains|startsWith|endsWith|like|in|nin|<|<=|>|>=|!=|!)\s*:[^}]*,\s*[a-zA-Z0-9_]*$/
+  )
+  if (insideOperatorObject) {
+    return []
+  }
+
   const criteriaMatch = before.match(
     /(?:sails\.models\.([A-Za-z_$][\w$]*)|([A-Za-z_$][\w$]*))\s*\.\w+\s*\(\s*\{[^}]*([a-zA-Z0-9_]*)?$/
   )
@@ -107,6 +150,23 @@ module.exports = function modelAttributesCompletion(
   const models = typeMap.models || {}
   const modelKeys = Object.keys(models)
 
+  // Helper to check if an identifier is a known Sails model
+  function isLikelyModel(name) {
+    if (!name) return false
+    const knownGlobals = [
+      '_',
+      'sails',
+      'require',
+      'module',
+      'exports',
+      'console',
+      'process'
+    ]
+    if (knownGlobals.includes(name)) return false
+    const upper = name.charAt(0).toUpperCase() + name.slice(1)
+    return !!(typeMap.models && typeMap.models[upper])
+  }
+
   // Better model name inference using last static model call
   function inferModelName(before) {
     const allMatches = [
@@ -119,6 +179,296 @@ module.exports = function modelAttributesCompletion(
     return last[1] || last[2] || null
   }
 
+  // AST-based detection: Check if cursor is inside a Waterline query object
+  // This handles nested contexts like or/and/not modifiers and operator objects
+  try {
+    const ast = acorn.parse(text, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      locations: true
+    })
+
+    let astModelName = null
+    let astPrefix = ''
+    let foundContext = false
+
+    walk.ancestor(ast, {
+      CallExpression(node, ancestors) {
+        if (!node.callee || node.callee.type !== 'MemberExpression') return
+
+        // Only trigger for query methods, not chainable methods
+        const method = node.callee.property?.name
+        const queryMethods = [
+          'find',
+          'findOne',
+          'create',
+          'createEach',
+          'update',
+          'destroy',
+          'count',
+          'sum',
+          'findOrCreate',
+          'where'
+        ]
+        if (!queryMethods.includes(method)) return
+
+        // Extract model name from call chain
+        let obj = node.callee.object
+        while (obj) {
+          if (obj.type === 'Identifier') {
+            if (isLikelyModel(obj.name)) {
+              astModelName = obj.name
+            }
+            break
+          } else if (
+            obj.type === 'CallExpression' &&
+            obj.callee &&
+            obj.callee.type === 'MemberExpression'
+          ) {
+            obj = obj.callee.object
+          } else {
+            break
+          }
+        }
+
+        if (!astModelName) return
+
+        // Helper to get model by name
+        function getModelByName(name) {
+          if (!name) return undefined
+          const upper = name.charAt(0).toUpperCase() + name.slice(1)
+          return typeMap.models[upper]
+        }
+
+        // Check if cursor is inside an argument object
+        const arg = node.arguments[0]
+        if (!arg || arg.type !== 'ObjectExpression') return
+        if (offset < arg.start || offset > arg.end) return
+
+        // Query option keys that should NOT be treated as model attributes
+        const queryOptionKeys = [
+          'where',
+          'select',
+          'omit',
+          'sort',
+          'limit',
+          'skip',
+          'page',
+          'populate',
+          'groupBy',
+          'having',
+          'sum',
+          'average',
+          'min',
+          'max',
+          'distinct',
+          'meta'
+        ]
+
+        // Recursively check if cursor is in a valid attribute position
+        function checkObjectForCursor(objNode, isInsideWhere = false) {
+          if (!objNode || objNode.type !== 'ObjectExpression') return false
+          if (offset < objNode.start || offset > objNode.end) return false
+
+          // Determine if this object contains any model attributes (vs only query options)
+          let hasAttributes = false
+          let hasQueryOptions = false
+          let hasOperators = false
+          for (const prop of objNode.properties) {
+            if (!prop.key) continue
+            const keyName = prop.key.name || prop.key.value
+            if (queryOptionKeys.includes(keyName)) {
+              hasQueryOptions = true
+            } else if (WATERLINE_OPERATORS.includes(keyName)) {
+              hasOperators = true
+            } else if (!WATERLINE_MODIFIERS.includes(keyName)) {
+              // Check if it's a valid attribute
+              const model = getModelByName(astModelName)
+              if (
+                model &&
+                model.attributes &&
+                Object.prototype.hasOwnProperty.call(model.attributes, keyName)
+              ) {
+                hasAttributes = true
+              }
+            }
+          }
+
+          // If this object contains operators, it's an operator object - don't show completions
+          if (hasOperators) {
+            return false
+          }
+
+          // Determine context:
+          // - If we have query options (like where, select, limit), this is a query options object
+          // - If we're explicitly inside a where clause (isInsideWhere), show attributes
+          // - If we have attributes but no query options, it's a criteria object
+          const isCriteriaMode =
+            isInsideWhere || (hasAttributes && !hasQueryOptions)
+
+          // If we have query options and we're not inside where, this is NOT a criteria context
+          // Don't show attribute completions at the query options level
+          if (hasQueryOptions && !isInsideWhere) {
+            // But we still need to check if we're typing a new key after existing query options
+            // Check if cursor is in a position to type a new key
+            const isTypingNewKey =
+              objNode.properties.length > 0 &&
+              offset > objNode.properties[objNode.properties.length - 1].end &&
+              offset < objNode.end
+
+            if (isTypingNewKey) {
+              // Don't show attributes, this should show query option keys instead
+              return false
+            }
+          }
+
+          for (const prop of objNode.properties) {
+            if (!prop.key) continue
+
+            // Check if cursor is at the key position (typing attribute name)
+            if (offset >= prop.key.start && offset <= prop.key.end) {
+              const keyName = prop.key.name || prop.key.value
+              // Skip if it's a modifier or operator
+              if (
+                WATERLINE_MODIFIERS.includes(keyName) ||
+                WATERLINE_OPERATORS.includes(keyName)
+              ) {
+                return false
+              }
+              // Skip query option keys if we're in criteria mode
+              if (isCriteriaMode && queryOptionKeys.includes(keyName)) {
+                return false
+              }
+              astPrefix = text.substring(prop.key.start, offset)
+              return true
+            }
+
+            const keyName = prop.key.name || prop.key.value
+
+            // If it's 'where', check inside its object value
+            if (keyName === 'where') {
+              if (prop.value && prop.value.type === 'ObjectExpression') {
+                if (checkObjectForCursor(prop.value, true)) return true
+              }
+            }
+
+            // If it's a modifier (or/and/not), check inside the array
+            if (WATERLINE_MODIFIERS.includes(keyName)) {
+              if (
+                prop.value &&
+                prop.value.type === 'ArrayExpression' &&
+                prop.value.elements
+              ) {
+                for (const el of prop.value.elements) {
+                  if (el && el.type === 'ObjectExpression') {
+                    if (checkObjectForCursor(el, true)) return true
+                  }
+                }
+              }
+            }
+
+            // If the value is an object with operators, don't recurse into it
+            if (
+              prop.value &&
+              prop.value.type === 'ObjectExpression' &&
+              prop.value.properties &&
+              prop.value.properties.length > 0
+            ) {
+              const firstKey =
+                prop.value.properties[0].key?.name ||
+                prop.value.properties[0].key?.value
+              if (WATERLINE_OPERATORS.includes(firstKey)) {
+                // This is an operator object like { '>': 100 } or { in: [...] }
+                // Don't provide completions inside operator values
+                continue
+              }
+            }
+
+            // If the value is an array and we're inside it, check if this is an operator value
+            // For example: { in: ['val1', 'val2'] } - don't complete inside the array
+            if (
+              prop.value &&
+              prop.value.type === 'ArrayExpression' &&
+              offset >= prop.value.start &&
+              offset <= prop.value.end
+            ) {
+              // Check if this property key is an operator
+              if (WATERLINE_OPERATORS.includes(keyName)) {
+                // We're inside an operator's array value - don't provide attribute completions
+                return false
+              }
+            }
+          }
+
+          // Check if cursor is after last property (typing new attribute)
+          if (objNode.properties.length > 0) {
+            const lastProp = objNode.properties[objNode.properties.length - 1]
+            if (offset > lastProp.end && offset < objNode.end) {
+              // Cursor is after last property, typing new attribute
+              const afterLast = text.substring(lastProp.end, offset)
+              const newKeyMatch = afterLast.match(/[,\s]*([a-zA-Z0-9_]*)$/)
+              if (newKeyMatch) {
+                astPrefix = newKeyMatch[1]
+                // Return true to indicate we found a valid context
+                // The isCriteriaMode flag will be used when building completions
+                return true
+              }
+            }
+          } else {
+            // Empty object, check if cursor is inside
+            const insideText = text.substring(objNode.start + 1, offset)
+            const newKeyMatch = insideText.match(/^\s*([a-zA-Z0-9_]*)$/)
+            if (newKeyMatch) {
+              astPrefix = newKeyMatch[1]
+              return true
+            }
+          }
+
+          return false
+        }
+
+        if (checkObjectForCursor(arg)) {
+          foundContext = true
+        }
+      }
+    })
+
+    if (foundContext && astModelName) {
+      modelName = astModelName
+      prefix = astPrefix
+      const foundKey = modelKeys.find(
+        (k) => k.toLowerCase() === modelName.toLowerCase()
+      )
+      const model = foundKey ? models[foundKey] : null
+      if (model) {
+        attributes = Object.keys(model.attributes || {})
+        return Array.from(
+          new Set(
+            attributes.filter((attr) =>
+              attr.toLowerCase().startsWith(prefix.toLowerCase())
+            )
+          )
+        ).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
+          }
+        })
+      }
+    }
+  } catch (err) {
+    // Fall through to regex-based detection
+  }
+
   // 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.

package/completions/model-methods-completion.js

@@ -11,6 +11,23 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
   const offset = document.offsetAt(position)
   const before = text.substring(0, offset)
 
+  // Don't provide method completions when cursor is inside an object or array literal
+  // Count opening and closing braces/brackets to determine if we're inside one
+  const lastOpenBrace = before.lastIndexOf('{')
+  const lastCloseBrace = before.lastIndexOf('}')
+  const lastOpenBracket = before.lastIndexOf('[')
+  const lastCloseBracket = before.lastIndexOf(']')
+
+  if (lastOpenBrace !== -1 && lastOpenBrace > lastCloseBrace) {
+    // We're inside an object literal, don't show method completions
+    return []
+  }
+
+  if (lastOpenBracket !== -1 && lastOpenBracket > lastCloseBracket) {
+    // We're inside an array literal, don't show method completions
+    return []
+  }
+
   // Match static calls like User.method or sails.models.user.method
   const staticCallMatch = before.match(
     /(?:sails\.models\.([A-Za-z_$][\w$]*)|([A-Za-z_$][\w$]*))\.\s*([a-zA-Z]*)?$/
@@ -33,7 +50,13 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
     // 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]) || ''
+
+    // Only provide chainable method completions if there's a dot after the call
+    if (!prefixMatch) {
+      return []
+    }
+
+    prefix = prefixMatch[1] || ''
     const foundKey = Object.keys(models).find(
       (k) => k.toLowerCase() === modelName.toLowerCase()
     )

package/go-to-definitions/go-to-action.js

@@ -1,43 +1,96 @@
 const lsp = require('vscode-languageserver/node')
 const path = require('path')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
 
 module.exports = async function goToAction(document, position, typeMap) {
   const fileName = path.basename(document.uri)
-  if (fileName !== 'routes.js') return []
+  if (fileName !== 'routes.js') return null
 
   const text = document.getText()
   const offset = document.offsetAt(position)
 
-  const regex =
-    /:\s*(?:{[^}]*?\baction\s*:\s*(?<quote>['"])(?<action>[^'"]+)\k<quote>[^}]*?}|(?<quoteAlt>['"])(?<actionAlt>[^'"]+)\k<quoteAlt>)/g
+  try {
+    const ast = acorn.parse(text, {
+      ecmaVersion: 'latest',
+      sourceType: 'module'
+    })
 
-  let match
+    let result = null
 
-  while ((match = regex.exec(text)) !== null) {
-    const actionName = match.groups.action || match.groups.actionAlt
-    const quote = match.groups.quote || match.groups.quoteAlt
-    const fullMatchStart =
-      match.index + match[0].indexOf(quote + actionName + quote)
-    const fullMatchEnd = fullMatchStart + actionName.length + 2 // +2 for quotes
-
-    if (offset >= fullMatchStart && offset <= fullMatchEnd) {
-      const routeEntry = Object.values(typeMap.routes).find(
-        (route) => route.action?.name === actionName
-      )
-      if (routeEntry?.action) {
-        const { path: actionPath, fnLine } = routeEntry.action
-        const uri = `file://${actionPath}`
-        return lsp.LocationLink.create(
-          uri,
-          lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
-          lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
-          lsp.Range.create(
-            document.positionAt(fullMatchStart),
-            document.positionAt(fullMatchEnd)
-          )
-        )
+    walk.simple(ast, {
+      Property(node) {
+        if (
+          node.value &&
+          node.value.type === 'Literal' &&
+          typeof node.value.value === 'string'
+        ) {
+          const actionName = node.value.value
+          if (
+            !actionName.startsWith('/') &&
+            !actionName.startsWith('http://') &&
+            !actionName.startsWith('https://')
+          ) {
+            if (offset >= node.value.start && offset <= node.value.end) {
+              const routeEntry = Object.values(typeMap.routes).find(
+                (route) => route.action?.name === actionName
+              )
+              if (routeEntry?.action) {
+                const { path: actionPath, fnLine } = routeEntry.action
+                const uri = `file://${actionPath}`
+                result = lsp.LocationLink.create(
+                  uri,
+                  lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
+                  lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
+                  lsp.Range.create(
+                    document.positionAt(node.value.start),
+                    document.positionAt(node.value.end)
+                  )
+                )
+              }
+            }
+          }
+        } else if (
+          node.value &&
+          node.value.type === 'ObjectExpression' &&
+          node.value.properties
+        ) {
+          for (const prop of node.value.properties) {
+            if (
+              prop.type === 'Property' &&
+              prop.key &&
+              (prop.key.name === 'action' || prop.key.value === 'action') &&
+              prop.value &&
+              prop.value.type === 'Literal' &&
+              typeof prop.value.value === 'string'
+            ) {
+              const actionName = prop.value.value
+              if (offset >= prop.value.start && offset <= prop.value.end) {
+                const routeEntry = Object.values(typeMap.routes).find(
+                  (route) => route.action?.name === actionName
+                )
+                if (routeEntry?.action) {
+                  const { path: actionPath, fnLine } = routeEntry.action
+                  const uri = `file://${actionPath}`
+                  result = lsp.LocationLink.create(
+                    uri,
+                    lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
+                    lsp.Range.create(fnLine - 1, 0, fnLine - 1, 0),
+                    lsp.Range.create(
+                      document.positionAt(prop.value.start),
+                      document.positionAt(prop.value.end)
+                    )
+                  )
+                }
+              }
+            }
+          }
+        }
       }
-    }
+    })
+
+    return result
+  } catch (error) {
+    return null
   }
-  return []
 }