@sailshq/language-server 0.3.2 → 0.5.0

package/validators/validate-data-type.js

@@ -1,34 +1,97 @@
 const lsp = require('vscode-languageserver/node')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
 
 module.exports = function validateDataType(document, typeMap) {
   const diagnostics = []
-
   const text = document.getText()
 
-  // Regex to match lines like: type: 'string' or type: "number"
-  const regex = /type\s*:\s*['"]([a-zA-Z0-9_-]+)['"]/g
-
-  let match
-  while ((match = regex.exec(text)) !== null) {
-    const dataType = match[1]
-    const typeStart = match.index + match[0].indexOf(dataType)
-    const typeEnd = typeStart + dataType.length
-
-    const isValid = typeMap.dataTypes.some((dt) => dt.type === dataType)
-
-    if (!isValid) {
-      diagnostics.push(
-        lsp.Diagnostic.create(
-          lsp.Range.create(
-            document.positionAt(typeStart),
-            document.positionAt(typeEnd)
-          ),
-          `'${dataType}' is not a recognized data type. Valid data types are: ${typeMap.dataTypes.map((dataType) => dataType.type).join(', ')}.`,
-          lsp.DiagnosticSeverity.Error,
-          'sails-lsp'
-        )
-      )
-    }
+  try {
+    const ast = acorn.parse(text, {
+      ecmaVersion: 'latest',
+      sourceType: 'module'
+    })
+
+    walk.simple(ast, {
+      ObjectExpression(node) {
+        // Check if this object has both 'type' and other properties that suggest it's a definition
+        // (like 'required', 'description', 'allowNull', 'defaultsTo', 'example', etc.)
+        let hasTypeProperty = false
+        let typePropertyNode = null
+        let typeValue = null
+        let hasDefinitionProperties = false
+
+        for (const prop of node.properties) {
+          if (prop.type !== 'Property') continue
+
+          const keyName = prop.key.name || prop.key.value
+
+          // Check if this is a 'type' property
+          if (keyName === 'type' && prop.value.type === 'Literal') {
+            hasTypeProperty = true
+            typePropertyNode = prop.value
+            typeValue = prop.value.value
+          }
+
+          // Check for properties that indicate this is a model/action/helper definition
+          if (
+            [
+              'required',
+              'description',
+              'allowNull',
+              'defaultsTo',
+              'columnName',
+              'columnType',
+              'autoMigrations',
+              'autoCreatedAt',
+              'autoUpdatedAt',
+              'model',
+              'collection',
+              'via',
+              'through',
+              'unique',
+              'isEmail',
+              'isURL',
+              'isIn',
+              'min',
+              'max',
+              'minLength',
+              'maxLength',
+              'example',
+              'validations',
+              'regex',
+              'extendedDescription',
+              'moreInfoUrl',
+              'whereToGet'
+            ].includes(keyName)
+          ) {
+            hasDefinitionProperties = true
+          }
+        }
+
+        // Only validate if this looks like an attribute/input definition
+        if (hasTypeProperty && hasDefinitionProperties && typeValue) {
+          const isValid = typeMap.dataTypes.some((dt) => dt.type === typeValue)
+
+          if (!isValid) {
+            diagnostics.push(
+              lsp.Diagnostic.create(
+                lsp.Range.create(
+                  document.positionAt(typePropertyNode.start),
+                  document.positionAt(typePropertyNode.end)
+                ),
+                `'${typeValue}' is not a recognized data type. Valid data types are: ${typeMap.dataTypes.map((dataType) => dataType.type).join(', ')}.`,
+                lsp.DiagnosticSeverity.Error,
+                'sails-lsp'
+              )
+            )
+          }
+        }
+      }
+    })
+  } catch (error) {
+    // Ignore parse errors
   }
+
   return diagnostics
 }

package/validators/validate-helper-input-exist.js

@@ -1,42 +1,108 @@
 const lsp = require('vscode-languageserver/node')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
 
 module.exports = function validateHelperInputExist(document, typeMap) {
   const diagnostics = []
   const text = document.getText()
 
-  // Regex to match sails.helpers.foo.bar.with({ ... })
-  // Captures: 1) helper path, 2) object literal content
-  const regex = /sails\.helpers((?:\.[a-zA-Z0-9_]+)+)\.with\s*\(\s*\{([^}]*)\}/g
-  let match
-  while ((match = regex.exec(text)) !== null) {
-    // Build helper name: e.g. .foo.bar => foo/bar
-    const segments = match[1].split('.').filter(Boolean)
-    const toKebab = (s) => s.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()
-    const fullHelperName = segments.map(toKebab).join('/')
-    const helperInfo = typeMap.helpers && typeMap.helpers[fullHelperName]
-    if (!helperInfo || !helperInfo.inputs) continue
-
-    // Find all property names in the object literal
-    const propsRegex = /([a-zA-Z0-9_]+)\s*:/g
-    let propMatch
-    while ((propMatch = propsRegex.exec(match[2])) !== null) {
-      const key = propMatch[1]
-      if (!Object.prototype.hasOwnProperty.call(helperInfo.inputs, key)) {
-        const start = match.index + match[0].indexOf(key)
-        const end = start + key.length
-        diagnostics.push(
-          lsp.Diagnostic.create(
-            lsp.Range.create(
-              document.positionAt(start),
-              document.positionAt(end)
-            ),
-            `Unknown input property '${key}' for helper '${fullHelperName}'.`,
-            lsp.DiagnosticSeverity.Error,
-            'sails-lsp'
-          )
-        )
+  try {
+    const ast = acorn.parse(text, {
+      ecmaVersion: 'latest',
+      sourceType: 'module'
+    })
+
+    walk.simple(ast, {
+      CallExpression(node) {
+        // Match sails.helpers.foo.bar.with({ ... })
+        if (
+          node.callee &&
+          node.callee.type === 'MemberExpression' &&
+          node.callee.property.name === 'with' &&
+          node.callee.object &&
+          node.callee.object.type === 'MemberExpression'
+        ) {
+          // Extract helper path from sails.helpers.foo.bar
+          const helperPath = extractHelperPath(node.callee.object)
+          if (!helperPath) return
+
+          const helperInfo = typeMap.helpers && typeMap.helpers[helperPath]
+          if (!helperInfo || !helperInfo.inputs) return
+
+          // Get the object argument to .with()
+          const objArg = node.arguments[0]
+          if (!objArg || objArg.type !== 'ObjectExpression') return
+
+          // Validate each property in the object
+          for (const prop of objArg.properties) {
+            // Handle both regular properties and shorthand properties
+            let key
+            if (prop.type === 'Property') {
+              if (prop.key.type === 'Identifier') {
+                key = prop.key.name
+              } else if (prop.key.type === 'Literal') {
+                key = prop.key.value
+              }
+            } else if (prop.type === 'SpreadElement') {
+              // Skip spread elements
+              continue
+            }
+
+            if (!key) continue
+
+            // Check if this key exists in the helper's inputs
+            if (!Object.prototype.hasOwnProperty.call(helperInfo.inputs, key)) {
+              diagnostics.push(
+                lsp.Diagnostic.create(
+                  lsp.Range.create(
+                    document.positionAt(prop.key.start),
+                    document.positionAt(prop.key.end)
+                  ),
+                  `Unknown input property '${key}' for helper '${helperPath}'.`,
+                  lsp.DiagnosticSeverity.Error,
+                  'sails-lsp'
+                )
+              )
+            }
+          }
+        }
       }
-    }
+    })
+  } catch (error) {
+    // Ignore parse errors
   }
+
   return diagnostics
 }
+
+function extractHelperPath(node) {
+  // Walk up the member expression to extract the full helper path
+  const segments = []
+  let current = node
+
+  // Collect all segments until we reach sails.helpers
+  while (current && current.type === 'MemberExpression') {
+    if (current.property && current.property.type === 'Identifier') {
+      const propName = current.property.name
+      // Stop when we reach 'helpers'
+      if (propName === 'helpers') {
+        // Check if the object is 'sails'
+        if (
+          current.object &&
+          current.object.type === 'Identifier' &&
+          current.object.name === 'sails'
+        ) {
+          // Valid sails.helpers path found
+          const toKebab = (s) =>
+            s.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()
+          return segments.map(toKebab).join('/')
+        }
+        return null
+      }
+      segments.unshift(propName)
+    }
+    current = current.object
+  }
+
+  return null
+}

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

@@ -2,6 +2,126 @@ const lsp = require('vscode-languageserver/node')
 const acorn = require('acorn')
 const walk = require('acorn-walk')
 
+/**
+ * Waterline query modifiers and operators
+ */
+const WATERLINE_MODIFIERS = ['or', 'and', 'not']
+const WATERLINE_OPERATORS = [
+  '<',
+  '<=',
+  '>',
+  '>=',
+  '!=',
+  'nin',
+  'in',
+  'contains',
+  'startsWith',
+  'endsWith',
+  'like',
+  '!'
+]
+
+/**
+ * Helper function to recursively validate criteria attributes
+ * @param {Object} objNode - AST ObjectExpression node
+ * @param {Object} model - Model with attributes
+ * @param {TextDocument} document - Text document
+ * @param {Array} diagnostics - Diagnostics array to push to
+ * @param {string} effectiveModelName - Model name for error messages
+ */
+function validateCriteriaAttributes(
+  objNode,
+  model,
+  document,
+  diagnostics,
+  effectiveModelName
+) {
+  if (!objNode || objNode.type !== 'ObjectExpression' || !objNode.properties) {
+    return
+  }
+
+  for (const prop of objNode.properties) {
+    if (!prop.key) continue
+    const attrName = prop.key.name || prop.key.value
+
+    if (WATERLINE_MODIFIERS.includes(attrName)) {
+      if (
+        prop.value &&
+        prop.value.type === 'ArrayExpression' &&
+        prop.value.elements
+      ) {
+        for (const el of prop.value.elements) {
+          if (el && el.type === 'ObjectExpression') {
+            validateCriteriaAttributes(
+              el,
+              model,
+              document,
+              diagnostics,
+              effectiveModelName
+            )
+          }
+        }
+      } else if (prop.value && prop.value.type === 'ObjectExpression') {
+        validateCriteriaAttributes(
+          prop.value,
+          model,
+          document,
+          diagnostics,
+          effectiveModelName
+        )
+      }
+      continue
+    }
+
+    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)) {
+        if (
+          !model.attributes ||
+          !Object.prototype.hasOwnProperty.call(model.attributes, attrName)
+        ) {
+          diagnostics.push(
+            lsp.Diagnostic.create(
+              lsp.Range.create(
+                document.positionAt(prop.key.start),
+                document.positionAt(prop.key.end)
+              ),
+              `'${attrName}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+              lsp.DiagnosticSeverity.Error,
+              'sails-lsp'
+            )
+          )
+        }
+        continue
+      }
+    }
+
+    if (
+      !model.attributes ||
+      !Object.prototype.hasOwnProperty.call(model.attributes, attrName)
+    ) {
+      diagnostics.push(
+        lsp.Diagnostic.create(
+          lsp.Range.create(
+            document.positionAt(prop.key.start),
+            document.positionAt(prop.key.end)
+          ),
+          `'${attrName}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+          lsp.DiagnosticSeverity.Error,
+          'sails-lsp'
+        )
+      )
+    }
+  }
+}
+
 /**
  * Validate if a Waterline model attribute exists when used in criteria or chainable methods.
  * @param {TextDocument} document - The text document to validate.
@@ -26,6 +146,36 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
     return typeMap.models[upper]
   }
 
+  // Helper to check if an identifier is likely a Sails model
+  function isLikelyModel(name) {
+    if (!name) return false
+
+    // Exclude common globals and libraries
+    const knownGlobals = [
+      '_',
+      'sails',
+      'require',
+      'module',
+      'exports',
+      'console',
+      'process'
+    ]
+    if (knownGlobals.includes(name)) {
+      return false
+    }
+
+    // Check if it's in the typeMap models (case-insensitive)
+    const upper = name.charAt(0).toUpperCase() + name.slice(1)
+    if (typeMap.models && typeMap.models[upper]) {
+      return true
+    }
+    // Also check lowercase version
+    if (typeMap.models && typeMap.models[name.toLowerCase()]) {
+      return true
+    }
+    return false
+  }
+
   // AST-based: Validate Model.create({ ... }) and similar
   try {
     const ast = acorn.parse(text, {
@@ -53,6 +203,9 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
               break
             }
           }
+          // Only proceed if this is actually a known Sails model
+          if (!isLikelyModel(effectiveModelName)) return
+
           const model = getModelByName(effectiveModelName)
           if (!model) return
 
@@ -287,63 +440,42 @@ module.exports = function validateModelAttributeExist(document, typeMap) {
                 'and',
                 'not'
               ]
-              // 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'
-                    )
+              // For non-create methods, use the helper to validate criteria
+              if (method !== 'create' && method !== 'createEach') {
+                if (!queryOptionKeys.includes(attribute)) {
+                  validateCriteriaAttributes(
+                    { type: 'ObjectExpression', properties: [prop] },
+                    model,
+                    document,
+                    diagnostics,
+                    effectiveModelName
                   )
-                }
-                continue
-              }
-              if (
-                method !== 'create' &&
-                method !== 'createEach' &&
-                queryOptionKeys.includes(attribute)
-              ) {
-                if (
+                } else if (
                   attribute === 'where' &&
                   prop.value &&
                   prop.value.type === 'ObjectExpression'
                 ) {
-                  for (const whereProp of prop.value.properties) {
-                    if (!whereProp.key) continue
-                    const whereAttr = whereProp.key.name || whereProp.key.value
-                    if (
-                      !model.attributes ||
-                      !Object.prototype.hasOwnProperty.call(
-                        model.attributes,
-                        whereAttr
-                      )
-                    ) {
-                      diagnostics.push(
-                        lsp.Diagnostic.create(
-                          lsp.Range.create(
-                            document.positionAt(whereProp.key.start),
-                            document.positionAt(whereProp.key.end)
-                          ),
-                          `'${whereAttr}' is not a valid attribute of model '${effectiveModelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
-                          lsp.DiagnosticSeverity.Error,
-                          'sails-lsp'
-                        )
+                  validateCriteriaAttributes(
+                    prop.value,
+                    model,
+                    document,
+                    diagnostics,
+                    effectiveModelName
+                  )
+                  continue
+                } else if (
+                  WATERLINE_MODIFIERS.includes(attribute) &&
+                  prop.value &&
+                  prop.value.type === 'ArrayExpression'
+                ) {
+                  for (const el of prop.value.elements) {
+                    if (el && el.type === 'ObjectExpression') {
+                      validateCriteriaAttributes(
+                        el,
+                        model,
+                        document,
+                        diagnostics,
+                        effectiveModelName
                       )
                     }
                   }

package/validators/validate-model-exist.js

@@ -19,12 +19,26 @@ module.exports = function validateModelExist(document, typeMap) {
     if (!name) return false
     return !!modelMap[name.toLowerCase()]
   }
+
+  const knownGlobals = [
+    '_',
+    'sails',
+    'require',
+    'module',
+    'exports',
+    'console',
+    'process'
+  ]
+
   // User.find() or User.create() etc
   const modelCallRegex =
     /\b([A-Za-z0-9_]+)\s*\.(?:find|findOne|create|createEach|update|destroy|count|sum|where|findOrCreate)\s*\(/g
   let match
   while ((match = modelCallRegex.exec(text)) !== null) {
     const modelName = match[1]
+    if (knownGlobals.includes(modelName)) {
+      continue
+    }
     if (!modelExists(modelName)) {
       diagnostics.push(
         lsp.Diagnostic.create(