@sailshq/language-server 0.0.5 → 0.2.0

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

@@ -0,0 +1,297 @@
+const lsp = require('vscode-languageserver/node')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
+
+/**
+ * Validate if a Waterline model attribute exists when used in criteria or chainable methods.
+ * @param {TextDocument} document - The text document to validate.
+ * @param {Object} typeMap - The type map containing models and their attributes.
+ * @returns {Array} diagnostics - Array of LSP diagnostics.
+ */
+module.exports = function validateModelAttributeExist(document, typeMap) {
+  const diagnostics = []
+  const text = document.getText()
+
+  // Build a lowercased model map for robust case-insensitive lookup
+  const modelMap = {}
+  if (typeMap.models) {
+    for (const key of Object.keys(typeMap.models)) {
+      modelMap[key.toLowerCase()] = typeMap.models[key]
+    }
+  }
+  // Helper function to get model by name, case-insensitive
+  function getModelByName(name) {
+    if (!name) return undefined
+    const upper = name.charAt(0).toUpperCase() + name.slice(1)
+    return typeMap.models[upper]
+  }
+
+  // AST-based: Validate Model.create({ ... }) and similar
+  try {
+    const ast = acorn.parse(text, {
+      ecmaVersion: 'latest',
+      sourceType: 'module'
+    })
+    walk.simple(ast, {
+      CallExpression(node) {
+        if (
+          node.callee &&
+          node.callee.type === 'MemberExpression' &&
+          node.arguments &&
+          node.arguments.length > 0 &&
+          node.arguments[0].type === 'ObjectExpression'
+        ) {
+          const method = node.callee.property.name
+          const modelName = node.callee.object.name
+          // Only check for Waterline methods
+          if (
+            [
+              'create',
+              'createEach',
+              'count',
+              'find',
+              'findOne',
+              'update',
+              'destroy',
+              'where',
+              'findOrCreate',
+              'sum'
+            ].includes(method)
+          ) {
+            const model = getModelByName(modelName)
+            if (!model) return
+            for (const prop of node.arguments[0].properties) {
+              const attribute = prop.key && (prop.key.name || prop.key.value)
+              const queryOptionKeys = [
+                'where',
+                'select',
+                'omit',
+                'sort',
+                'limit',
+                'skip',
+                'page',
+                'populate',
+                'groupBy',
+                'having',
+                'sum',
+                'average',
+                'min',
+                'max',
+                'distinct',
+                'meta'
+              ]
+              // --- FINAL FIX: treat 'where' exactly like 'sort', 'select', 'omit' for non-create methods ---
+              if (
+                method !== 'create' &&
+                method !== 'createEach' &&
+                queryOptionKeys.includes(attribute)
+              ) {
+                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 '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                          lsp.DiagnosticSeverity.Error,
+                          'sails-lsp'
+                        )
+                      )
+                    }
+                  }
+                  continue
+                }
+                if (
+                  (attribute === 'select' || attribute === 'omit') &&
+                  prop.value &&
+                  prop.value.type === 'ArrayExpression'
+                ) {
+                  for (const el of prop.value.elements) {
+                    if (!el) continue
+                    if (el.type === 'Literal' || el.type === 'StringLiteral') {
+                      const arrAttr = el.value
+                      if (
+                        !model.attributes ||
+                        !Object.prototype.hasOwnProperty.call(
+                          model.attributes,
+                          arrAttr
+                        )
+                      ) {
+                        diagnostics.push(
+                          lsp.Diagnostic.create(
+                            lsp.Range.create(
+                              document.positionAt(el.start),
+                              document.positionAt(el.end)
+                            ),
+                            `'${arrAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                            lsp.DiagnosticSeverity.Error,
+                            'sails-lsp'
+                          )
+                        )
+                      }
+                    }
+                  }
+                  continue
+                }
+                if (attribute === 'sort' && prop.value) {
+                  if (
+                    prop.value.type === 'Literal' ||
+                    prop.value.type === 'StringLiteral'
+                  ) {
+                    const sortStr = prop.value.value
+                    const sortAttr = sortStr && sortStr.split(' ')[0]
+                    if (
+                      sortAttr &&
+                      (!model.attributes ||
+                        !Object.prototype.hasOwnProperty.call(
+                          model.attributes,
+                          sortAttr
+                        ))
+                    ) {
+                      diagnostics.push(
+                        lsp.Diagnostic.create(
+                          lsp.Range.create(
+                            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(', ')}`,
+                          lsp.DiagnosticSeverity.Error,
+                          'sails-lsp'
+                        )
+                      )
+                    }
+                    continue
+                  } else if (prop.value.type === 'ArrayExpression') {
+                    for (const el of prop.value.elements) {
+                      if (!el) continue
+                      if (el.type === 'ObjectExpression') {
+                        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 '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                                lsp.DiagnosticSeverity.Error,
+                                'sails-lsp'
+                              )
+                            )
+                          }
+                        }
+                      } else if (
+                        el.type === 'Literal' ||
+                        el.type === 'StringLiteral'
+                      ) {
+                        const sortStr = el.value
+                        const sortAttr = sortStr && sortStr.split(' ')[0]
+                        if (
+                          sortAttr &&
+                          (!model.attributes ||
+                            !Object.prototype.hasOwnProperty.call(
+                              model.attributes,
+                              sortAttr
+                            ))
+                        ) {
+                          diagnostics.push(
+                            lsp.Diagnostic.create(
+                              lsp.Range.create(
+                                document.positionAt(el.start),
+                                document.positionAt(el.end)
+                              ),
+                              `'${sortAttr}' is not a valid attribute of model '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                              lsp.DiagnosticSeverity.Error,
+                              'sails-lsp'
+                            )
+                          )
+                        }
+                      }
+                    }
+                    continue
+                  } else if (prop.value.type === 'ObjectExpression') {
+                    for (const sortProp of prop.value.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 '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                            lsp.DiagnosticSeverity.Error,
+                            'sails-lsp'
+                          )
+                        )
+                      }
+                    }
+                    continue
+                  }
+                }
+                // For all other query option keys, skip validation
+                continue
+              }
+              // --- END ROBUST FIX ---
+              // Only validate top-level for create/createEach
+              if (
+                (method === 'create' || method === 'createEach') &&
+                (!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 '${modelName}'. Valid attributes: ${Object.keys(model.attributes || {}).join(', ')}`,
+                    lsp.DiagnosticSeverity.Error,
+                    'sails-lsp'
+                  )
+                )
+              }
+            }
+          }
+        }
+      }
+    })
+  } catch (err) {
+    // No regex fallback: rely solely on AST-based validation for accuracy
+  }
+  return diagnostics
+}

package/validators/validate-model-exist.js

@@ -0,0 +1,64 @@
+const lsp = require('vscode-languageserver/node')
+/**
+ * Validate if a referenced model exists in Sails.js queries using regex.
+ * @param {TextDocument} document - The text document to validate.
+ * @param {Object} typeMap - The type map containing models.
+ * @returns {Array} diagnostics - Array of LSP diagnostics.
+ */
+module.exports = function validateModelExist(document, typeMap) {
+  const diagnostics = []
+  const text = document.getText()
+  // Build a lowercased model map for robust case-insensitive lookup
+  const modelMap = {}
+  if (typeMap.models) {
+    for (const key of Object.keys(typeMap.models)) {
+      modelMap[key.toLowerCase()] = typeMap.models[key]
+    }
+  }
+  function modelExists(name) {
+    if (!name) return false
+    return !!modelMap[name.toLowerCase()]
+  }
+  // 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 (!modelExists(modelName)) {
+      diagnostics.push(
+        lsp.Diagnostic.create(
+          lsp.Range.create(
+            document.positionAt(match.index),
+            document.positionAt(match.index + modelName.length)
+          ),
+          `Model '${modelName}' not found. Make sure it exists under your api/models directory.`,
+          lsp.DiagnosticSeverity.Error,
+          'sails-lsp'
+        )
+      )
+    }
+  }
+  // sails.models.user.find() or sails.models.User.find()
+  const sailsModelCallRegex =
+    /sails\.models\.([A-Za-z0-9_]+)\s*\.(?:find|findOne|create|createEach|update|destroy|count|sum|where|findOrCreate)\s*\(/g
+  while ((match = sailsModelCallRegex.exec(text)) !== null) {
+    const modelName = match[1]
+    if (!modelExists(modelName)) {
+      diagnostics.push(
+        lsp.Diagnostic.create(
+          lsp.Range.create(
+            document.positionAt(match.index + 'sails.models.'.length),
+            document.positionAt(
+              match.index + 'sails.models.'.length + modelName.length
+            )
+          ),
+          `Model '${modelName}' does not exist in this Sails project.`,
+          lsp.DiagnosticSeverity.Error,
+          'sails-lsp'
+        )
+      )
+    }
+  }
+  return diagnostics
+}

package/validators/validate-page-exist.js

@@ -0,0 +1,42 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function validatePageExist(document, typeMap) {
+  const diagnostics = []
+
+  const pages = extractPageReferences(document)
+  for (const { page, range } of pages) {
+    if (!typeMap.pages?.[page]) {
+      diagnostics.push(
+        lsp.Diagnostic.create(
+          range,
+          `Inertia page '${page}' not found. Make sure it exists under your /assets/js/pages directory.`,
+          lsp.DiagnosticSeverity.Error,
+          'sails-lsp'
+        )
+      )
+    }
+  }
+  return diagnostics
+}
+
+function extractPageReferences(document) {
+  const text = document.getText()
+  const regex = /\bpage\s*:\s*['"]([^'"]+)['"]/g
+  const pages = []
+
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const page = match[1]
+    const pageStart = match.index + match[0].indexOf(page)
+    const pageEnd = pageStart + page.length
+
+    pages.push({
+      page,
+      range: lsp.Range.create(
+        document.positionAt(pageStart),
+        document.positionAt(pageEnd)
+      )
+    })
+  }
+  return pages
+}

package/validators/validate-policy-exist.js

@@ -0,0 +1,45 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function validatePolicyExist(document, typeMap) {
+  const diagnostics = []
+  if (!document.uri.endsWith('policies.js')) return diagnostics
+
+  const policyRefs = extractPolicyReferences(document)
+  for (const { policy, range } of policyRefs) {
+    if (!typeMap.policies?.[policy]) {
+      diagnostics.push(
+        lsp.Diagnostic.create(
+          range,
+          `Policy '${policy}' not found. Make sure it exists in api/policies.`,
+          lsp.DiagnosticSeverity.Error,
+          'sails-lsp'
+        )
+      )
+    }
+  }
+
+  return diagnostics
+}
+
+function extractPolicyReferences(document) {
+  const text = document.getText()
+  const policyRegex = /(?::|=)\s*(?:\[\s*)?['"]([^'"]+)['"]/g
+  const policies = []
+
+  let match
+  while ((match = policyRegex.exec(text)) !== null) {
+    const policy = match[1]
+    const policyStart = match.index + match[0].indexOf(policy)
+    const policyEnd = policyStart + policy.length
+
+    policies.push({
+      policy,
+      range: lsp.Range.create(
+        document.positionAt(policyStart),
+        document.positionAt(policyEnd)
+      )
+    })
+  }
+
+  return policies
+}

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

@@ -0,0 +1,49 @@
+const lsp = require('vscode-languageserver/node')
+
+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'
+          )
+        )
+      }
+    }
+  }
+  return diagnostics
+}

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

@@ -0,0 +1,56 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function validateRequiredModelAttribute(document, typeMap) {
+  const diagnostics = []
+  const text = document.getText()
+  const models = typeMap.models || {}
+
+  // For each model, check for .create({ ... }) and .createEach({ ... }) calls
+  for (const [modelName, modelInfo] of Object.entries(models)) {
+    if (!modelInfo || !modelInfo.attributes) continue
+    // Only validate required attributes for create and createEach
+    const methodRegex = new RegExp(
+      `${modelName}\\s*\\.\\s*(create|createEach)\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`,
+      'g'
+    )
+    let match
+    while ((match = methodRegex.exec(text)) !== null) {
+      // match[2] is the object literal content
+      // Find all property names in the object literal, including shorthand
+      const propsRegex = /([a-zA-Z0-9_]+)\s*:/g
+      const shorthandRegex = /([a-zA-Z0-9_]+)\s*(,|(?=\n|\}))/g
+      let propMatch
+      const providedKeys = new Set()
+      while ((propMatch = propsRegex.exec(match[2])) !== null) {
+        providedKeys.add(propMatch[1])
+      }
+      while ((propMatch = shorthandRegex.exec(match[2])) !== null) {
+        if (!providedKeys.has(propMatch[1])) {
+          providedKeys.add(propMatch[1])
+        }
+      }
+      // Check for missing required attributes
+      for (const [attr, def] of Object.entries(modelInfo.attributes)) {
+        const isRequired =
+          def && (def.required === true || def.required === 'true')
+        if (isRequired && !providedKeys.has(attr)) {
+          // 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 attribute '${attr}' in ${modelName}.${match[1]}().`,
+              lsp.DiagnosticSeverity.Error,
+              'sails-lsp'
+            )
+          )
+        }
+      }
+    }
+  }
+  return diagnostics
+}

package/validators/validate-view-exist.js

@@ -0,0 +1,86 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function validateViewExist(document, typeMap) {
+  const diagnostics = []
+
+  // Only check routes.js and actions (api/controllers)
+  const isRoutes = document.uri.endsWith('routes.js')
+  const isAction = document.uri.includes('/api/controllers/')
+  if (!isRoutes && !isAction) return diagnostics
+
+  // Extract { view: '...' } in routes.js
+  if (isRoutes) {
+    const views = extractViewReferences(document)
+    for (const { view, range } of views) {
+      if (!typeMap.views?.[view]) {
+        diagnostics.push(
+          lsp.Diagnostic.create(
+            range,
+            `View '${view}' not found. Make sure it exists in your /views directory.`,
+            lsp.DiagnosticSeverity.Error,
+            'sails-lsp'
+          )
+        )
+      }
+    }
+  }
+
+  // Extract viewTemplatePath: '...' in actions
+  if (isAction) {
+    const exits = extractViewTemplatePathReferences(document)
+    for (const { view, range } of exits) {
+      if (!typeMap.views?.[view]) {
+        diagnostics.push(
+          lsp.Diagnostic.create(
+            range,
+            `View '${view}' not found. Make sure it exists in your /views directory.`,
+            lsp.DiagnosticSeverity.Error,
+            'sails-lsp'
+          )
+        )
+      }
+    }
+  }
+
+  return diagnostics
+}
+
+function extractViewReferences(document) {
+  const text = document.getText()
+  const regex = /view\s*:\s*['"]([^'"]+)['"]/g
+  const views = []
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const view = match[1]
+    const viewStart = match.index + match[0].indexOf(view)
+    const viewEnd = viewStart + view.length
+    views.push({
+      view,
+      range: lsp.Range.create(
+        document.positionAt(viewStart),
+        document.positionAt(viewEnd)
+      )
+    })
+  }
+  return views
+}
+
+function extractViewTemplatePathReferences(document) {
+  const text = document.getText()
+  const regex = /viewTemplatePath\s*:\s*['"]([^'"]+)['"]/g
+  const views = []
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const view = match[1]
+    const viewStart = match.index + match[0].indexOf(view)
+    const viewEnd = viewStart + view.length
+    views.push({
+      view,
+      range: lsp.Range.create(
+        document.positionAt(viewStart),
+        document.positionAt(viewEnd)
+      )
+    })
+  }
+  return views
+}