@sailshq/language-server 0.3.1 → 0.4.0

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

@@ -2,6 +2,118 @@ 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
+            )
+          }
+        }
+      }
+      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 +138,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 +195,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,66 +432,28 @@ 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
+              // 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
                   )
-                ) {
-                  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' &&
-                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
                 }
                 if (

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(

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

@@ -1,49 +1,109 @@
 const lsp = require('vscode-languageserver/node')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
 
 module.exports = function validateRequiredHelperInput(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
-    const providedKeys = new Set()
-    while ((propMatch = propsRegex.exec(match[2])) !== null) {
-      providedKeys.add(propMatch[1])
-    }
-    // Check for missing required inputs (support boolean or string 'required')
-    for (const [inputKey, inputDef] of Object.entries(helperInfo.inputs)) {
-      const isRequired =
-        inputDef && (inputDef.required === true || inputDef.required === 'true')
-      if (isRequired && !providedKeys.has(inputKey)) {
-        // Find the start/end of the object literal for the diagnostic range
-        const objStart = match.index + match[0].indexOf('{')
-        const objEnd = objStart + match[2].length + 1 // +1 for closing }
-        diagnostics.push(
-          lsp.Diagnostic.create(
-            lsp.Range.create(
-              document.positionAt(objStart),
-              document.positionAt(objEnd)
-            ),
-            `Missing required input '${inputKey}' 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
+
+          // Collect provided keys (handles both regular and shorthand properties)
+          const providedKeys = new Set()
+          for (const prop of objArg.properties) {
+            if (prop.type === 'Property') {
+              if (prop.key.type === 'Identifier') {
+                providedKeys.add(prop.key.name)
+              } else if (prop.key.type === 'Literal') {
+                providedKeys.add(prop.key.value)
+              }
+            }
+          }
+
+          // Check for missing required inputs
+          for (const [inputKey, inputDef] of Object.entries(
+            helperInfo.inputs
+          )) {
+            const isRequired =
+              inputDef &&
+              (inputDef.required === true || inputDef.required === 'true')
+            if (isRequired && !providedKeys.has(inputKey)) {
+              diagnostics.push(
+                lsp.Diagnostic.create(
+                  lsp.Range.create(
+                    document.positionAt(objArg.start),
+                    document.positionAt(objArg.end)
+                  ),
+                  `Missing required input '${inputKey}' 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
+}