@sailshq/language-server 0.1.0 → 0.2.1

package/completions/input-props-completion.js

@@ -13,12 +13,17 @@ module.exports = function inputPropsCompletion(document, position, typeMap) {
   const offset = document.offsetAt(position)
   const before = text.substring(0, offset)
 
+  const lines = before.split('\n')
+  const lastLine = lines[lines.length - 1]
+
+  // Only trigger if we're on a new line with optional whitespace (no code)
+  if (!/^\s*$/.test(lastLine)) return []
+
   // Check we're inside the inputs: { ... } section
   const insideInputs = /inputs\s*:\s*{[\s\S]*$/.test(before)
   if (!insideInputs) return []
 
-  // Walk backward to see if we're inside an input property definition
-  const lines = before.split('\n')
+  // Walk backward to see if we're inside an input block
   const reversed = lines.slice().reverse()
   let insideInputBlock = false
 
@@ -28,29 +33,20 @@ module.exports = function inputPropsCompletion(document, position, typeMap) {
       insideInputBlock = true
       break
     }
-    if (/^\}/.test(trimmed)) {
-      break // exited a block
-    }
+    if (/^\}/.test(trimmed)) break
   }
 
   if (!insideInputBlock) return []
 
-  // Extract current typing prefix
-  const lastLine = lines[lines.length - 1]
-  const prefixMatch = lastLine.match(/([a-zA-Z0-9_]*)$/)
-  const prefix = prefixMatch ? prefixMatch[1] : ''
-
-  return typeMap.inputProps
-    .filter(({ label }) => label.startsWith(prefix))
-    .map(({ label, detail }) => ({
-      label,
-      kind:
-        label === 'custom'
-          ? lsp.CompletionItemKind.Method
-          : lsp.CompletionItemKind.Field,
-      detail,
-      documentation: detail,
-      insertText: `${label}: `,
-      insertTextFormat: lsp.InsertTextFormat.PlainText
-    }))
+  return typeMap.inputProps.map(({ label, detail }) => ({
+    label,
+    kind:
+      label === 'custom'
+        ? lsp.CompletionItemKind.Method
+        : lsp.CompletionItemKind.Field,
+    detail,
+    documentation: detail,
+    insertText: `${label}: `,
+    insertTextFormat: lsp.InsertTextFormat.PlainText
+  }))
 }

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

@@ -6,48 +6,52 @@ module.exports = function modelAttributePropsCompletion(
   typeMap
 ) {
   const filePath = document.uri
+  if (!filePath.includes('/api/models/')) return []
 
-  const isTargetFile = filePath.includes('/api/models/')
-  if (!isTargetFile) return []
   const text = document.getText()
   const offset = document.offsetAt(position)
   const before = text.substring(0, offset)
+  const lines = before.split('\n')
+  const lastLine = lines[lines.length - 1]
+
+  // Only trigger on an empty or whitespace-only line
+  if (!/^\s*$/.test(lastLine)) return []
 
   // Confirm we're inside the attributes section
-  const insideAttributes = /attributes\s*:\s*{[\s\S]*$/.test(before)
+  const insideAttributes = /attributes\s*:\s*{([\s\S]*)$/.exec(before)
   if (!insideAttributes) return []
 
-  // Try to match "someProperty: {" above the current line
-  const lines = before.split('\n')
-  const reversed = lines.slice().reverse()
-  let insidePropertyBlock = false
-
-  for (const line of reversed) {
-    const trimmed = line.trim()
-    if (/^[a-zA-Z0-9_]+\s*:\s*{\s*$/.test(trimmed)) {
-      insidePropertyBlock = true
-      break
-    }
-    if (/^\}/.test(trimmed)) {
-      break // exited a block without entering a new one
+  // 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--) {
+    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 (insideProperty) break
+    if (/^\s*attributes\s*:\s*{/.test(line)) break
   }
 
-  if (!insidePropertyBlock) return []
-
-  // Optional: match current prefix
-  const lastLine = lines[lines.length - 1]
-  const prefixMatch = lastLine.match(/([a-zA-Z0-9_]*)$/)
-  const prefix = prefixMatch ? prefixMatch[1] : ''
+  if (!insideProperty) return []
 
-  return typeMap.modelAttributeProps
-    .filter(({ label }) => label.startsWith(prefix))
-    .map(({ label, detail }) => ({
-      label,
-      kind: lsp.CompletionItemKind.Field,
-      detail,
-      documentation: detail,
-      insertText: `${label}: `,
-      insertTextFormat: lsp.InsertTextFormat.PlainText
-    }))
+  return typeMap.modelAttributeProps.map(({ label, detail }) => ({
+    label,
+    kind: lsp.CompletionItemKind.Field,
+    detail,
+    documentation: detail,
+    insertText: `${label}: `,
+    insertTextFormat: lsp.InsertTextFormat.PlainText
+  }))
 }

package/completions/model-attributes-completion.js

@@ -29,12 +29,71 @@ module.exports = function modelAttributesCompletion(
   )
   const sortStringMatch = before.match(/sort\s*:\s*['"]([a-zA-Z0-9_]*)?$/)
   const sortArrayStringMatch = before.match(
-    /sort\s*:\s*\[\s*[^{\]]*['"]([a-zA-Z0-9_]*)?$/
+    /sort\s*:\s*\[\s*[^\{\]]*['"]([a-zA-Z0-9_]*)?$/
   )
   const sortArrayObjectMatch = before.match(
     /sort\s*:\s*\[\s*\{\s*([a-zA-Z0-9_]*)?$/
   )
 
+  // Detect if we are inside a .select(['']), .omit(['']), .sort(['']), etc. chainable method call context
+  // This matches e.g. .select(['foo', '']) or .omit(["bar", '']) or .select('foo')
+  const chainableMethodCallRegex =
+    /\.(select|omit|sort)\s*\(\s*([\[\{]?[^\)]*)$/
+  const isInChainableMethodCall = chainableMethodCallRegex.test(before)
+
+  // Detect if we are inside a .select([]), .omit([]), .sort([]), etc. as a method call (e.g. User.find().select([]))
+  // This matches e.g. .select(['foo', '']) or .omit(["bar", '']) or .select('foo')
+  const chainableDirectCallMatch = before.match(
+    /\.(select|omit|sort|populate|where)\s*\(\s*\[?\s*['"]?([a-zA-Z0-9_]*)?$/
+  )
+
+  // Also allow completions in .where({ ... }) chainable method call context
+  const whereMethodCallRegex = /\.where\s*\(\s*\{[^\)]*$/
+  const isInWhereMethodCall = whereMethodCallRegex.test(before)
+
+  // Add: detect .where({ ... }) context for modelName/prefix inference
+  const whereMethodCallMatch = before.match(
+    /([A-Za-z_$][\w$]*)\s*\.where\s*\(\s*\{[^}]*([a-zA-Z0-9_]*)?$/
+  )
+
+  // Only suppress completions after a colon (:) in object literals for static methods,
+  // but always allow completions in .select(['']), .omit(['']), .sort(['']), .where({}), etc.
+  const inChainableString =
+    selectStringMatch ||
+    selectArrayMatch ||
+    sortStringMatch ||
+    sortArrayStringMatch ||
+    sortArrayObjectMatch ||
+    populateStringMatch ||
+    isInChainableMethodCall ||
+    isInWhereMethodCall ||
+    !!chainableDirectCallMatch
+
+  // Suppress completions after a colon only if NOT in a chainable string/array context
+  if (!inChainableString) {
+    const lines = before.split('\n')
+    const line = lines[lines.length - 1]
+    const beforeCursor = line.slice(0, position.character)
+    // If the last non-whitespace character before the cursor is a colon, suppress completion
+    // (but allow after comma, or at start of line/object)
+    const lastColon = beforeCursor.lastIndexOf(':')
+    const lastComma = beforeCursor.lastIndexOf(',')
+    if (lastColon > lastComma && lastColon > beforeCursor.lastIndexOf('{')) {
+      // Check if we are inside a string (e.g. after a colon and inside quotes)
+      // If so, suppress completion
+      const quoteBefore = beforeCursor.lastIndexOf("'")
+      const dquoteBefore = beforeCursor.lastIndexOf('"')
+      if (
+        (quoteBefore > lastColon && quoteBefore > lastComma) ||
+        (dquoteBefore > lastColon && dquoteBefore > lastComma)
+      ) {
+        return []
+      }
+      // Otherwise, suppress completion after colon
+      return []
+    }
+  }
+
   let modelName,
     prefix,
     attributes,
@@ -69,6 +128,12 @@ module.exports = function modelAttributesCompletion(
     modelName = inferModelName(before)
     prefix =
       (sortStringMatch || sortArrayStringMatch || sortArrayObjectMatch)[1] || ''
+  } else if (whereMethodCallMatch) {
+    modelName = whereMethodCallMatch[1]
+    prefix = whereMethodCallMatch[2] || ''
+  } else if (chainableDirectCallMatch) {
+    modelName = inferModelName(before)
+    prefix = chainableDirectCallMatch[2] || ''
   } else {
     return []
   }
@@ -80,6 +145,27 @@ module.exports = function modelAttributesCompletion(
   const model = foundKey ? models[foundKey] : null
   if (!model) return []
 
+  // Find already-used property names in the current object literal (if inside one)
+  let usedProps = new Set()
+  // Use the text before the cursor to find the nearest opening brace
+  const beforeCursorFull = text.slice(0, offset)
+  const lastOpen = beforeCursorFull.lastIndexOf('{')
+  const lastClose = beforeCursorFull.lastIndexOf('}')
+  if (lastOpen !== -1 && (lastClose === -1 || lastOpen > lastClose)) {
+    // Only consider properties before the cursor
+    const objectText = beforeCursorFull.slice(lastOpen, offset)
+    // Match both foo: ... and object shorthand foo,
+    const propRegex = /([a-zA-Z0-9_]+)\s*:/g
+    const shorthandRegex = /([a-zA-Z0-9_]+)\s*,/g
+    let m
+    while ((m = propRegex.exec(objectText)) !== null) {
+      usedProps.add(m[1])
+    }
+    while ((m = shorthandRegex.exec(objectText)) !== null) {
+      usedProps.add(m[1])
+    }
+  }
+
   if (isPopulate) {
     attributes = Object.entries(model.attributes || {})
       .filter(([, def]) => def && (def.model || def.collection))
@@ -90,13 +176,20 @@ module.exports = function modelAttributesCompletion(
 
   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
-    }))
+    .filter((attr) => !usedProps.has(attr))
+    .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
+      }
+    })
 }

package/completions/model-methods-completion.js

@@ -48,14 +48,24 @@ module.exports = function modelMethodsCompletion(document, position, typeMap) {
 
   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
-    }))
+    .map((method) => {
+      let insertText = method.name + '($0)'
+      // For chainable .select or .omit, insert ([''])
+      if (
+        chainableCallMatch &&
+        (method.name === 'select' || method.name === 'omit')
+      ) {
+        insertText = method.name + '([$0])'
+      }
+      return {
+        label: method.name,
+        kind: lsp.CompletionItemKind.Method,
+        detail: method.description,
+        documentation: `${modelName}.${method.name}()`,
+        sortText: method.name,
+        filterText: method.name,
+        insertText,
+        insertTextFormat: lsp.InsertTextFormat.Snippet
+      }
+    })
 }

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

@@ -8,40 +8,45 @@ module.exports = async function goToHelper(document, position, typeMap) {
   const text = document.getText()
   const offset = document.offsetAt(position)
 
-  // 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
+  // Regex to match sails.helpers.foo.bar (even if chained, e.g. .with, .with(), .with({}), etc.)
+  // This is similar to go-to-model: match the helper path, then allow any chain after
+  const regex = /\bsails\.helpers((?:\.[A-Za-z0-9_]+)+)/g
 
   let match
-
   while ((match = regex.exec(text)) !== null) {
-    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)
-          )
+    const segments = match[1].slice(1).split('.') // drop the leading dot
+    if (!segments.length) continue
+
+    // Only use the last segment before .with as the helper name
+    let cleanSegments = segments
+    if (segments[segments.length - 1] === 'with') {
+      cleanSegments = segments.slice(0, -1)
+    }
+    const fullHelperName = cleanSegments.map(toKebab).join('/')
+    const lastSeg = cleanSegments[cleanSegments.length - 1]
+    const helperStart = match.index + match[0].lastIndexOf(lastSeg)
+    const helperEnd = helperStart + lastSeg.length
+
+    // Allow go-to if the cursor is anywhere inside the helper name
+    if (offset < helperStart || offset > helperEnd) {
+      continue
+    }
+
+    // Now look up in your typeMap
+    const info = typeMap.helpers?.[fullHelperName]
+    if (info?.path) {
+      const uri = `file://${info.path}`
+      return lsp.LocationLink.create(
+        uri,
+        lsp.Range.create(info.fnLine - 1, 0, info.fnLine - 1, 0),
+        lsp.Range.create(info.fnLine - 1, 0, info.fnLine - 1, 0),
+        lsp.Range.create(
+          document.positionAt(helperStart),
+          document.positionAt(helperEnd)
         )
-      }
+      )
     }
   }
+
   return null
 }

package/index.js

@@ -24,6 +24,9 @@ const policiesCompletion = require('./completions/policies-completion')
 const viewsCompletion = require('./completions/views-completion')
 const modelMethodsCompletion = require('./completions/model-methods-completion')
 const modelAttributesCompletion = require('./completions/model-attributes-completion')
+const helperInputsCompletion = require('./completions/helper-inputs-completion')
+const helpersCompletion = require('./completions/helpers-completion')
+
 const connection = lsp.createConnection(lsp.ProposedFeatures.all)
 const documents = new lsp.TextDocuments(TextDocument)
 
@@ -116,7 +119,9 @@ connection.onCompletion(async (params) => {
     policyCompletion,
     viewCompletion,
     modelMethodCompletion,
-    modelAttributeCompletion
+    modelAttributeCompletion,
+    helperCompletion,
+    helperInputCompletion
   ] = await Promise.all([
     actionsCompletion(document, params.position, typeMap),
     dataTypesCompletion(document, params.position, typeMap),
@@ -127,7 +132,9 @@ connection.onCompletion(async (params) => {
     policiesCompletion(document, params.position, typeMap),
     viewsCompletion(document, params.position, typeMap),
     modelMethodsCompletion(document, params.position, typeMap),
-    modelAttributesCompletion(document, params.position, typeMap)
+    modelAttributesCompletion(document, params.position, typeMap),
+    helpersCompletion(document, params.position, typeMap),
+    helperInputsCompletion(document, params.position, typeMap)
   ])
 
   const completions = [
@@ -140,7 +147,9 @@ connection.onCompletion(async (params) => {
     ...policyCompletion,
     ...viewCompletion,
     ...modelMethodCompletion,
-    ...modelAttributeCompletion
+    ...modelAttributeCompletion,
+    ...helperCompletion,
+    ...helperInputCompletion
   ].filter(Boolean)
 
   if (completions) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailshq/language-server",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Language Server Protocol server for Sails Language Service",
   "homepage": "https://sailjs.com",
   "repository": {
@@ -20,6 +20,8 @@
   "author": "Kelvin Omereshone",
   "license": "MIT",
   "dependencies": {
+    "acorn": "^8.14.1",
+    "acorn-walk": "^8.3.4",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
   },

package/validators/validate-document.js

@@ -4,6 +4,12 @@ const validatePageExist = require('./validate-page-exist')
 const validateDataTypes = require('./validate-data-type')
 const validatePolicyExist = require('./validate-policy-exist')
 const validateModelAttributeExist = require('./validate-model-attribute-exist')
+const validateViewExist = require('./validate-view-exist')
+const validateHelperInputExist = require('./validate-helper-input-exist')
+const validateRequiredHelperInput = require('./validate-required-helper-input')
+const validateRequiredModelAttribute = require('./validate-required-model-attribute')
+const validateModelExist = require('./validate-model-exist')
+
 module.exports = function validateDocument(connection, document, typeMap) {
   const diagnostics = []
 
@@ -16,13 +22,29 @@ module.exports = function validateDocument(connection, document, typeMap) {
     document,
     typeMap
   )
+  const viewDiagnostics = validateViewExist(document, typeMap)
+  const helperInputDiagnostics = validateHelperInputExist(document, typeMap)
+  const requiredHelperInputDiagnostics = validateRequiredHelperInput(
+    document,
+    typeMap
+  )
+  const requiredModelAttributeDiagnostics = validateRequiredModelAttribute(
+    document,
+    typeMap
+  )
+  const modelExistDiagnostics = validateModelExist(document, typeMap)
   diagnostics.push(
     ...modelDiagnostics,
     ...actionDiagnostics,
     ...pageDiagnostics,
     ...dataTypeDiagnostics,
     ...policyDiagnostics,
-    ...modelAttributeDiagnostics
+    ...modelAttributeDiagnostics,
+    ...viewDiagnostics,
+    ...helperInputDiagnostics,
+    ...requiredHelperInputDiagnostics,
+    ...requiredModelAttributeDiagnostics,
+    ...modelExistDiagnostics
   )
 
   connection.sendDiagnostics({ uri: document.uri, diagnostics })

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

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