@sailshq/language-server 0.0.5 → 0.1.0

package/completions/model-attributes-completion.js

@@ -0,0 +1,102 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function modelAttributesCompletion(
+  document,
+  position,
+  typeMap
+) {
+  const JS_FILE_TYPES = ['helpers', 'controllers', 'scripts', 'models']
+  const isRelevantFile = JS_FILE_TYPES.some((type) =>
+    document.uri.includes(`${type}/`)
+  )
+  if (!isRelevantFile) return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  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(
+    /(?: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 sortArrayObjectMatch = before.match(
+    /sort\s*:\s*\[\s*\{\s*([a-zA-Z0-9_]*)?$/
+  )
+
+  let modelName,
+    prefix,
+    attributes,
+    isPopulate = false
+
+  const models = typeMap.models || {}
+  const modelKeys = Object.keys(models)
+
+  // Better model name inference using last static model call
+  function inferModelName(before) {
+    const allMatches = [
+      ...before.matchAll(
+        /(?:sails\.models\.([A-Za-z_$][\w$]*)|([A-Z][A-Za-z0-9_]*))\s*\./g
+      )
+    ]
+    if (allMatches.length === 0) return null
+    const last = allMatches[allMatches.length - 1]
+    return last[1] || last[2] || null
+  }
+
+  if (criteriaMatch) {
+    modelName = criteriaMatch[1] || criteriaMatch[2]
+    prefix = criteriaMatch[3] || ''
+  } else if (selectStringMatch || selectArrayMatch) {
+    modelName = inferModelName(before)
+    prefix = (selectStringMatch || selectArrayMatch)[1] || ''
+  } else if (populateStringMatch) {
+    isPopulate = true
+    modelName = inferModelName(before)
+    prefix = populateStringMatch[1] || ''
+  } else if (sortStringMatch || sortArrayStringMatch || sortArrayObjectMatch) {
+    modelName = inferModelName(before)
+    prefix =
+      (sortStringMatch || sortArrayStringMatch || sortArrayObjectMatch)[1] || ''
+  } else {
+    return []
+  }
+
+  if (!modelName) return []
+  const foundKey = modelKeys.find(
+    (k) => k.toLowerCase() === modelName.toLowerCase()
+  )
+  const model = foundKey ? models[foundKey] : null
+  if (!model) return []
+
+  if (isPopulate) {
+    attributes = Object.entries(model.attributes || {})
+      .filter(([, def]) => def && (def.model || def.collection))
+      .map(([attr]) => attr)
+  } else {
+    attributes = Object.keys(model.attributes || {})
+  }
+
+  return attributes
+    .filter((attr) => attr.startsWith(prefix))
+    .map((attr) => ({
+      label: attr,
+      kind: lsp.CompletionItemKind.Field,
+      detail: `Attribute of ${modelName}`,
+      documentation: `${modelName}.${attr}`,
+      sortText: attr,
+      filterText: attr,
+      insertText: attr
+    }))
+}

package/completions/model-methods-completion.js

@@ -0,0 +1,61 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function modelMethodsCompletion(document, position, typeMap) {
+  const JS_FILE_TYPES = ['helpers', 'controllers', 'scripts', 'models']
+  const isRelevantFile = JS_FILE_TYPES.some((type) =>
+    document.uri.includes(`${type}/`)
+  )
+  if (!isRelevantFile) return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // 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]*)?$/
+  )
+  // 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]*)?$/
+  )
+
+  let modelName, prefix, methods
+
+  // Make model lookup case-insensitive
+  const models = typeMap.models || {}
+  const modelKeys = Object.keys(models)
+
+  if (chainableCallMatch) {
+    modelName = chainableCallMatch[1]
+    prefix = chainableCallMatch[2] || ''
+    if (!modelName) return []
+    const foundKey = modelKeys.find(
+      (k) => k.toLowerCase() === modelName.toLowerCase()
+    )
+    methods = foundKey ? models[foundKey].chainableMethods || [] : []
+  } else if (staticCallMatch) {
+    modelName = staticCallMatch[1] || staticCallMatch[2]
+    prefix = staticCallMatch[3] || ''
+    if (!modelName) return []
+    const foundKey = modelKeys.find(
+      (k) => k.toLowerCase() === modelName.toLowerCase()
+    )
+    methods = foundKey ? models[foundKey].methods || [] : []
+  } else {
+    return []
+  }
+
+  return methods
+    .filter((method) => method.name.startsWith(prefix))
+    .map((method) => ({
+      label: method.name,
+      kind: lsp.CompletionItemKind.Method,
+      detail: method.description,
+      documentation: `${modelName}.${method.name}()`,
+      sortText: method.name,
+      filterText: method.name,
+      insertText: method.name + '($0)',
+      insertTextFormat: lsp.InsertTextFormat.Snippet
+    }))
+}

package/completions/models-completion.js

@@ -0,0 +1,52 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function modelsCompletion(document, position, typeMap) {
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // sails.models.<model>
+  const dotMatch = before.match(/sails\.models\.([a-zA-Z0-9_]*)$/)
+  if (dotMatch) {
+    const prefix = dotMatch[1] || ''
+
+    return Object.entries(typeMap.models || {})
+      .map(([modelName, model]) => {
+        const key = modelName.toLowerCase()
+        if (!key.startsWith(prefix.toLowerCase())) return null
+
+        return {
+          label: key,
+          kind: lsp.CompletionItemKind.Class,
+          detail: 'Sails Model (sails.models)',
+          documentation: model.src?.replace(/^.*\/api\/models\//, ''),
+          insertText: key
+        }
+      })
+      .filter(Boolean)
+  }
+
+  // await User.<method>
+  // Only match if there's an uppercase prefix and it follows "await"
+  const awaitMatch = before.match(/(?:await\s+)([A-Z][a-zA-Z0-9_]*)$/)
+  if (awaitMatch) {
+    const prefix = awaitMatch[1]
+    if (!prefix) return [] // Don't show anything if prefix is empty
+
+    return Object.entries(typeMap.models || {})
+      .map(([modelName, model]) => {
+        if (!modelName.startsWith(prefix)) return null
+
+        return {
+          label: modelName,
+          kind: lsp.CompletionItemKind.Class,
+          detail: 'Sails Model',
+          documentation: model.path?.replace(/^.*\/api\/models\//, ''),
+          insertText: modelName
+        }
+      })
+      .filter(Boolean)
+  }
+
+  return []
+}

package/completions/policies-completion.js

@@ -0,0 +1,32 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function policiesCompletion(document, position, typeMap) {
+  if (!document.uri.endsWith('policies.js')) return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // Match inside string value or array of strings:
+  // 'isLog|' or ['isLog|'] or '*': 'isLog|'
+  const match = before.match(/:\s*(?:\[)?\s*['"]([^'"]*)$/)
+  if (!match) return []
+
+  const prefix = match[1]
+
+  return Object.entries(typeMap.policies || {})
+    .map(([policyName, policy]) => {
+      if (!policyName.startsWith(prefix)) return null
+
+      return {
+        label: policyName,
+        kind: lsp.CompletionItemKind.Function,
+        detail: 'Policy',
+        documentation: policy.path,
+        sortText: policyName,
+        filterText: policyName,
+        insertText: policyName
+      }
+    })
+    .filter(Boolean)
+}

package/completions/views-completion.js

@@ -0,0 +1,35 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function viewsCompletion(document, position, typeMap) {
+  const uri = document.uri
+  if (!uri.endsWith('routes.js') && !uri.includes('/api/controllers/'))
+    return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // Match { view: '...' } or viewTemplatePath: '...'
+  const match = before.match(/\b(view|viewTemplatePath)\s*:\s*['"]([^'"]*)$/)
+  if (!match) return []
+
+  const prefix = match[2]
+
+  const completions = Object.entries(typeMap.views || {})
+    .map(([viewKey, viewData]) => {
+      if (!viewKey.startsWith(prefix)) return null
+
+      return {
+        label: viewKey,
+        kind: lsp.CompletionItemKind.File,
+        detail: 'View',
+        documentation: viewData.path,
+        sortText: viewKey,
+        filterText: viewKey,
+        insertText: viewKey
+      }
+    })
+    .filter(Boolean)
+
+  return completions
+}

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

@@ -1,66 +1,43 @@
 const lsp = require('vscode-languageserver/node')
 const path = require('path')
-const findFnLine = require('../helpers/find-fn-line')
 
-module.exports = async function goToAction(document, position) {
+module.exports = async function goToAction(document, position, typeMap) {
   const fileName = path.basename(document.uri)
+  if (fileName !== 'routes.js') return null
 
-  if (fileName !== 'routes.js') {
-    return null
-  }
-  const actionInfo = extractActionInfo(document, position)
-
-  if (!actionInfo) {
-    return null
-  }
-
-  const projectRoot = path.dirname(path.dirname(document.uri))
-
-  const fullActionPath = resolveActionPath(projectRoot, actionInfo.action)
-
-  if (fullActionPath) {
-    const fnLineNumber = await findFnLine(fullActionPath)
-    return lsp.Location.create(
-      fullActionPath,
-      lsp.Range.create(fnLineNumber, 0, fnLineNumber, 0)
-    )
-  }
-
-  return null
-}
-
-function extractActionInfo(document, position) {
   const text = document.getText()
   const offset = document.offsetAt(position)
 
-  // This regex matches both object and string notations
-  const regex = /(['"])(.+?)\1:\s*(?:{?\s*action\s*:\s*)?(['"])(.+?)\3/g
+  const regex =
+    /:\s*(?:{[^}]*?\baction\s*:\s*(?<quote>['"])(?<action>[^'"]+)\k<quote>[^}]*?}|(?<quoteAlt>['"])(?<actionAlt>[^'"]+)\k<quoteAlt>)/g
+
   let match
 
   while ((match = regex.exec(text)) !== null) {
-    const [fullMatch, , route, , action] = match
-    const start = match.index
-    const end = start + fullMatch.length
-
-    // Check if the cursor is anywhere within the entire match
-    if (start <= offset && offset <= end) {
-      // Find the start and end positions of the action part
-      const actionStart = text.indexOf(action, start)
-      const actionEnd = actionStart + action.length
-
-      return {
-        action,
-        range: lsp.Range.create(
-          document.positionAt(actionStart),
-          document.positionAt(actionEnd)
+    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)
+          )
         )
       }
     }
   }
-
   return null
 }
-
-function resolveActionPath(projectRoot, actionPath) {
-  return path.join(projectRoot, 'api', 'controllers', `${actionPath}.js`)
-}

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

@@ -1,60 +1,47 @@
 const lsp = require('vscode-languageserver/node')
-const path = require('path')
-const fs = require('fs').promises
-const findProjectRoot = require('../helpers/find-project-root')
-const findFnLine = require('../helpers/find-fn-line')
 
-function camelToKebabCase(str) {
-  return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)
+function toKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()
 }
 
-function normalizeHelperPath(helperPath) {
-  const parts = helperPath.split('/')
-  const fileName = parts.pop() // Get the last part (file name)
-  const normalizedFileName = camelToKebabCase(fileName)
-  return [...parts, normalizedFileName].join('/')
-}
-
-module.exports = async function goToHelper(document, position) {
-  const helperInfo = extractHelperInfo(document, position)
-
-  if (!helperInfo) {
-    return null
-  }
-
-  const projectRoot = await findProjectRoot(document.uri)
-  const normalizedHelperPath = normalizeHelperPath(
-    helperInfo.helperPath.join('/')
-  )
-  const fullHelperPath =
-    path.join(projectRoot, 'api', 'helpers', normalizedHelperPath) + '.js'
-  if (fullHelperPath) {
-    const fnLineNumber = await findFnLine(fullHelperPath)
-    return lsp.Location.create(
-      fullHelperPath,
-      lsp.Range.create(fnLineNumber, 0, fnLineNumber, 0)
-    )
-  }
-}
-
-function extractHelperInfo(document, position) {
+module.exports = async function goToHelper(document, position, typeMap) {
   const text = document.getText()
   const offset = document.offsetAt(position)
 
-  // Regular expression to match sails.helpers.exampleHelper() or sails.helpers.exampleHelper.with()
-  // Also matches nested helpers like sails.helpers.mail.send() or sails.helpers.mail.send.with()
-  const regex = /sails\.helpers\.([a-zA-Z0-9.]+)(?:\.with)?\s*\(/g
+  // Match sails.helpers.foo or sails.helpers.bar.baz
+  const regex =
+    /\bsails\.helpers(?:\.(?<group>[a-zA-Z0-9_]+))?\.(?<helper>[a-zA-Z0-9_]+)(?![\w.])/g
+
   let match
 
   while ((match = regex.exec(text)) !== null) {
-    const start = match.index
-    const end = start + match[0].length
-
-    if (start <= offset && offset <= end) {
-      const helperPath = match[1].split('.').filter((part) => part !== 'with')
-      return { helperPath }
+    const { group, helper } = match.groups
+
+    const kebabGroup = group ? toKebab(group) : null
+    const kebabHelper = toKebab(helper)
+    const fullHelperName = kebabGroup
+      ? `${kebabGroup}/${kebabHelper}`
+      : kebabHelper
+
+    // Compute accurate range for just the helper name
+    const helperStart = match.index + match[0].lastIndexOf(helper)
+    const helperEnd = helperStart + helper.length
+
+    if (offset >= helperStart && offset <= helperEnd) {
+      const helperInfo = typeMap.helpers?.[fullHelperName]
+      if (helperInfo && helperInfo.path) {
+        const uri = `file://${helperInfo.path}`
+        return lsp.LocationLink.create(
+          uri,
+          lsp.Range.create(helperInfo.fnLine - 1, 0, helperInfo.fnLine - 1, 0),
+          lsp.Range.create(helperInfo.fnLine - 1, 0, helperInfo.fnLine - 1, 0),
+          lsp.Range.create(
+            document.positionAt(helperStart),
+            document.positionAt(helperEnd)
+          )
+        )
+      }
     }
   }
-
   return null
 }

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

@@ -0,0 +1,39 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = async function goToModel(document, position, typeMap) {
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+
+  const regex =
+    /\b(?:(?<classModel>[A-Z][a-zA-Z0-9_]*)|sails\.models\.(?<dotModel>[a-z][a-zA-Z0-9_]*))\s*\.\s*\w*/g
+
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const modelNameRaw = match.groups.classModel || match.groups.dotModel
+    const modelName =
+      match.groups.classModel ||
+      (match.groups.dotModel &&
+        match.groups.dotModel.charAt(0).toUpperCase() +
+          match.groups.dotModel.slice(1))
+
+    if (!modelName) continue
+
+    const start = match.index + match[0].indexOf(modelNameRaw)
+    const end = start + modelNameRaw.length
+
+    if (offset >= start && offset <= end) {
+      const model = typeMap.models?.[modelName]
+      if (!model?.path) return null
+
+      const uri = `file://${model.path}`
+      return lsp.LocationLink.create(
+        uri,
+        lsp.Range.create(0, 0, 0, 0), // target range (usually top of file)
+        lsp.Range.create(0, 0, 0, 0), // target selection range
+        lsp.Range.create(document.positionAt(start), document.positionAt(end)) // origin range
+      )
+    }
+  }
+
+  return null
+}

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

@@ -0,0 +1,38 @@
+const lsp = require('vscode-languageserver/node')
+module.exports = async function goToPage(document, position, typeMap) {
+  const filePath = document.uri
+  if (!filePath.includes('/api/controllers/')) return null
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+
+  const regex =
+    /{[^}]*?\bpage\s*:\s*(?<quote>['"])(?<page>[^'"]+)\k<quote>[^}]*?}/g
+
+  let match
+
+  while ((match = regex.exec(text)) !== null) {
+    const pageName = match.groups.page
+    const quote = match.groups.quote
+    const fullMatchStart =
+      match.index + match[0].indexOf(quote + pageName + quote)
+    const fullMatchEnd = fullMatchStart + pageName.length + 2 // +2 for quotes
+
+    if (offset >= fullMatchStart && offset <= fullMatchEnd) {
+      const pagePath = typeMap.pages?.[pageName]
+      if (pagePath) {
+        const uri = `file://${pagePath.path}`
+        return lsp.LocationLink.create(
+          uri,
+          lsp.Range.create(0, 0, 0, 0),
+          lsp.Range.create(0, 0, 0, 0),
+          lsp.Range.create(
+            document.positionAt(fullMatchStart),
+            document.positionAt(fullMatchEnd)
+          )
+        )
+      }
+    }
+  }
+
+  return null
+}

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

@@ -1,90 +1,41 @@
 const lsp = require('vscode-languageserver/node')
 const path = require('path')
-const fs = require('fs').promises
 
-module.exports = async function goToPolicy(document, position) {
+module.exports = async function goToPolicy(document, position, typeMap) {
   const fileName = path.basename(document.uri)
+  if (fileName !== 'policies.js') return null
 
-  if (fileName !== 'policies.js') {
-    return null
-  }
-
-  const policyInfo = extractPolicyInfo(document, position)
-
-  if (!policyInfo) {
-    return null
-  }
-
-  const projectRoot = path.dirname(path.dirname(document.uri))
-  const fullPolicyPath = resolvePolicyPath(projectRoot, policyInfo.policy)
-
-  if (await fileExists(fullPolicyPath)) {
-    return lsp.Location.create(fullPolicyPath, lsp.Range.create(0, 0, 0, 0))
-  }
-
-  return null
-}
-
-function extractPolicyInfo(document, position) {
   const text = document.getText()
   const offset = document.offsetAt(position)
 
-  // This regex matches policy definitions, including arrays of policies and boolean values
   const regex =
-    /(['"])((?:\*|[\w-]+(?:\/\*?)?))?\1\s*:\s*((?:\[?\s*(?:(?:['"][\w-]+['"](?:\s*,\s*)?)+)\s*\]?)|true|false)/g
+    /:\s*(\[\s*)?(?<quote>['"])(?<policy>[^'"]+)\k<quote>(\s*,\s*['"][^'"]+['"])*(\s*\])?/g
+
   let match
 
   while ((match = regex.exec(text)) !== null) {
-    const [fullMatch, , route, policiesOrBoolean] = match
-    const start = match.index
-    const end = start + fullMatch.length
-
-    // Check if the cursor is anywhere within the entire match
-    if (start <= offset && offset <= end) {
-      // If policiesOrBoolean is a boolean, ignore it
-      if (policiesOrBoolean === true || policiesOrBoolean === false) {
-        continue
-      }
-
-      // Remove brackets if present and split into individual policies
-      const policies = policiesOrBoolean
-        .replace(/^\[|\]$/g, '')
-        .split(',')
-        .map((p) => p.trim().replace(/^['"]|['"]$/g, ''))
-
-      // Find which policy the cursor is on
-      let currentStart = start + fullMatch.indexOf(policiesOrBoolean)
-      for (const policy of policies) {
-        const policyStart = text.indexOf(policy, currentStart)
-        const policyEnd = policyStart + policy.length
-
-        if (offset >= policyStart && offset <= policyEnd) {
-          return {
-            policy,
-            range: lsp.Range.create(
-              document.positionAt(policyStart),
-              document.positionAt(policyEnd)
-            )
-          }
-        }
-
-        currentStart = policyEnd
+    const policyName = match.groups.policy
+    const quote = match.groups.quote
+    const fullMatchStart =
+      match.index + match[0].indexOf(quote + policyName + quote)
+    const fullMatchEnd = fullMatchStart + policyName.length + 2
+
+    if (offset >= fullMatchStart && offset <= fullMatchEnd) {
+      const policyPath = typeMap.policies?.[policyName]
+      if (policyPath) {
+        const uri = `file://${policyPath.path}`
+        return lsp.LocationLink.create(
+          uri,
+          lsp.Range.create(0, 0, 0, 0),
+          lsp.Range.create(0, 0, 0, 0),
+          lsp.Range.create(
+            document.positionAt(fullMatchStart),
+            document.positionAt(fullMatchEnd)
+          )
+        )
       }
     }
   }
 
   return null
 }
-
-function resolvePolicyPath(projectRoot, policyPath) {
-  return path.join(projectRoot, 'api', 'policies', `${policyPath}.js`)
-}
-
-async function fileExists(filePath) {
-  try {
-    await fs.access(new URL(filePath))
-    return true
-  } catch {
-    return false
-  }
-}