@sailshq/language-server 0.0.5 → 0.2.0

package/completions/data-types-completion.js

@@ -0,0 +1,39 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function dataTypesCompletion(document, position, typeMap) {
+  const filePath = document.uri
+
+  const isTargetFile =
+    filePath.includes('/api/models/') ||
+    filePath.includes('/api/helpers/') ||
+    filePath.includes('/api/controllers/') ||
+    filePath.includes('/scripts/')
+
+  if (!isTargetFile) return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // Require `type: '` or `type: "` with optional partial type after it
+  const match = before.match(/type\s*:\s*(['"])([a-z]*)$/i)
+  if (!match) return []
+
+  const prefix = match[2] || ''
+
+  const contextText = before.toLowerCase()
+  const inAttributes = /attributes\s*:\s*{([\s\S]*)$/.test(contextText)
+  const inInputs = /inputs\s*:\s*{([\s\S]*)$/.test(contextText)
+
+  if (!(inAttributes || inInputs)) return []
+
+  return typeMap.dataTypes
+    .filter(({ type }) => type.startsWith(prefix))
+    .map(({ type, description }) => ({
+      label: type,
+      kind: lsp.CompletionItemKind.TypeParameter,
+      detail: 'Data type',
+      documentation: description,
+      insertText: type
+    }))
+}

package/completions/helper-inputs-completion.js

@@ -0,0 +1,91 @@
+const lsp = require('vscode-languageserver/node')
+
+// Find the helper path context from the line, e.g. sails.helpers.email.sendEmail.with({
+function getHelperPath(line) {
+  const match = line.match(
+    /sails\.helpers((?:\.[a-zA-Z0-9_]+)+)\.with\s*\(\s*\{[^}]*$/
+  )
+  if (!match) return null
+  // e.g. '.email.sendEmail' => ['email', 'sendEmail']
+  return match[1].split('.').filter(Boolean)
+}
+
+function getInputCompletionItems(inputsObj) {
+  if (!inputsObj || typeof inputsObj !== 'object') return []
+  return Object.entries(inputsObj).map(([inputName, inputDef]) => {
+    let type = inputDef?.type
+    let required = inputDef?.required ? 'required' : 'optional'
+    let description = inputDef?.description || ''
+    let detail = type ? `${type} (${required})` : required
+    return {
+      label: inputName,
+      kind: lsp.CompletionItemKind.Field,
+      detail: detail,
+      documentation: description,
+      insertText: `${inputName}: `
+    }
+  })
+}
+
+module.exports = function helperInputsCompletion(document, position, typeMap) {
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+  const lines = before.split('\n')
+  const line = lines[lines.length - 1]
+
+  // Only trigger if not after a colon (:) on this line
+  // e.g. don't trigger if "foo: '" or "foo: \"" or "foo: 1"
+  // But DO trigger after a comma (,) or at the start of a new property
+  // Find the text before the cursor on this line
+  const beforeCursor = line.slice(0, position.character)
+  // If the last non-whitespace character before the cursor is a colon, do not complete
+  // (but allow after comma, or at start of line/object)
+  const lastColon = beforeCursor.lastIndexOf(':')
+  const lastComma = beforeCursor.lastIndexOf(',')
+  // If the last colon is after the last comma, and after any opening brace, suppress completion
+  if (lastColon > lastComma && lastColon > beforeCursor.lastIndexOf('{'))
+    return []
+
+  const pathParts = getHelperPath(line)
+  if (!pathParts) return []
+
+  // Find already-used property names in the current object literal
+  // We'll look for all foo: ... pairs before the cursor in the current .with({ ... })
+  const objectStart = before.lastIndexOf('{')
+  const objectEnd = before.lastIndexOf('}')
+  let usedProps = new Set()
+  if (objectStart !== -1 && (objectEnd === -1 || objectStart > objectEnd)) {
+    // Get the text inside the current object literal up to the cursor
+    const objectText = before.slice(objectStart, offset)
+    // Match all property names before the cursor
+    const propRegex = /([a-zA-Z0-9_]+)\s*:/g
+    let m
+    while ((m = propRegex.exec(objectText)) !== null) {
+      usedProps.add(m[1])
+    }
+  }
+
+  // Convert camelCase to kebab-case for the last part
+  function camelToKebab(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()
+  }
+  // Try to find the helper in typeMap.helpers
+  let helperKey = pathParts.join('/')
+  let helper = typeMap.helpers[helperKey]
+  if (!helper) {
+    // Try kebab-case for last part
+    const last = pathParts[pathParts.length - 1]
+    pathParts[pathParts.length - 1] = camelToKebab(last)
+    helperKey = pathParts.join('/')
+    helper = typeMap.helpers[helperKey]
+  }
+  if (!helper || !helper.inputs || typeof helper.inputs !== 'object') return []
+
+  // Filter out already-used properties
+  const availableInputs = Object.fromEntries(
+    Object.entries(helper.inputs).filter(([key]) => !usedProps.has(key))
+  )
+
+  return getInputCompletionItems(availableInputs)
+}

package/completions/helpers-completion.js

@@ -0,0 +1,85 @@
+const { CompletionItemKind } = require('vscode-languageserver/node')
+
+// Convert kebab-case to camelCase (e.g., 'send-email' -> 'sendEmail')
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase())
+}
+
+// Get the helper path context from the line, e.g. sails.helpers.email.
+function getHelpersContext(line) {
+  const match = line.match(/sails\.helpers((?:\.[a-zA-Z0-9_]+)*)\.$/)
+  if (!match) return []
+  // e.g. '.email.foo.' => ['email', 'foo']
+  return match[1] ? match[1].split('.').filter(Boolean) : []
+}
+
+module.exports = function helpersCompletion(document, position, typeMap) {
+  const line = document.getText({
+    start: { line: position.line, character: 0 },
+    end: position
+  })
+  // Prevent helpers completion inside .with({ ... })
+  if (/\.with\s*\(\s*\{[^}]*$/.test(line)) {
+    return []
+  }
+  // Prevent helpers completion inside sails.helpers.foo({ ... })
+  if (/sails\.helpers(?:\.[a-zA-Z0-9_]+)+\s*\(\s*\{[^}]*$/.test(line)) {
+    return []
+  }
+  const helpers = typeMap.helpers || {}
+  const context = getHelpersContext(line.trim())
+  if (!line.trim().includes('sails.helpers.')) return []
+
+  // Build a tree of helpers from the flat keys
+  const tree = {}
+  for (const key of Object.keys(helpers)) {
+    const parts = key.split('/')
+    let node = tree
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i]
+      if (!node[part])
+        node[part] =
+          i === parts.length - 1 ? { __isHelper: true, __key: key } : {}
+      node = node[part]
+    }
+  }
+
+  // Traverse the tree according to the context
+  let node = tree
+  for (const part of context) {
+    if (!node[part]) return []
+    node = node[part]
+  }
+
+  // If at a namespace, suggest children (namespaces or helpers)
+  return Object.entries(node)
+    .filter(([k]) => !k.startsWith('__'))
+    .map(([k, v]) => {
+      if (v.__isHelper) {
+        const helperInfo = helpers[v.__key] || {}
+        // Updated: check if inputs is a non-empty object
+        const hasInputs =
+          helperInfo.inputs &&
+          typeof helperInfo.inputs === 'object' &&
+          Object.keys(helperInfo.inputs).length > 0
+        return {
+          label: kebabToCamel(k),
+          kind: CompletionItemKind.Method,
+          detail: helperInfo.description || 'Helper function',
+          documentation: helperInfo.path || '',
+          insertText: hasInputs
+            ? `${kebabToCamel(k)}.with({$0})`
+            : `${kebabToCamel(k)}()`,
+          insertTextFormat: 2 // Snippet
+        }
+      } else {
+        // Namespace/folder
+        return {
+          label: k,
+          kind: CompletionItemKind.Module,
+          detail: 'Helper namespace',
+          insertText: k + '.'
+        }
+      }
+    })
+}

package/completions/inertia-pages-completion.js

@@ -0,0 +1,33 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function inertiaPagesCompletion(document, position, typeMap) {
+  if (!document.uri.includes('/api/controllers/')) return []
+
+  const text = document.getText()
+  const offset = document.offsetAt(position)
+  const before = text.substring(0, offset)
+
+  // Match { page: '<cursor here>' } (either single or double quotes)
+  const match = before.match(/page\s*:\s*['"]([^'"]*)$/)
+  if (!match) return []
+
+  const prefix = match[1]
+
+  const completions = Object.entries(typeMap.pages || {})
+    .map(([pageKey, pageData]) => {
+      if (!pageKey.startsWith(prefix)) return null
+
+      return {
+        label: pageKey,
+        kind: lsp.CompletionItemKind.Module,
+        detail: 'Inertia Page',
+        documentation: pageData.path,
+        sortText: pageKey,
+        filterText: pageKey,
+        insertText: pageKey
+      }
+    })
+    .filter(Boolean)
+
+  return completions
+}

package/completions/input-props-completion.js

@@ -0,0 +1,52 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function inputPropsCompletion(document, position, typeMap) {
+  const filePath = document.uri
+
+  const isTargetFile =
+    filePath.includes('/api/helpers/') ||
+    filePath.includes('/api/controllers/') ||
+    filePath.includes('/scripts/')
+  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 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 block
+  const reversed = lines.slice().reverse()
+  let insideInputBlock = false
+
+  for (const line of reversed) {
+    const trimmed = line.trim()
+    if (/^[a-zA-Z0-9_]+\s*:\s*{\s*$/.test(trimmed)) {
+      insideInputBlock = true
+      break
+    }
+    if (/^\}/.test(trimmed)) break
+  }
+
+  if (!insideInputBlock) return []
+
+  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

@@ -0,0 +1,57 @@
+const lsp = require('vscode-languageserver/node')
+
+module.exports = function modelAttributePropsCompletion(
+  document,
+  position,
+  typeMap
+) {
+  const filePath = document.uri
+  if (!filePath.includes('/api/models/')) 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]*)$/.exec(before)
+  if (!insideAttributes) return []
+
+  // 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 (!insideProperty) return []
+
+  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

@@ -0,0 +1,195 @@
+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_]*)?$/
+  )
+
+  // 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,
+    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 if (whereMethodCallMatch) {
+    modelName = whereMethodCallMatch[1]
+    prefix = whereMethodCallMatch[2] || ''
+  } else if (chainableDirectCallMatch) {
+    modelName = inferModelName(before)
+    prefix = chainableDirectCallMatch[2] || ''
+  } else {
+    return []
+  }
+
+  if (!modelName) return []
+  const foundKey = modelKeys.find(
+    (k) => k.toLowerCase() === modelName.toLowerCase()
+  )
+  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))
+      .map(([attr]) => attr)
+  } else {
+    attributes = Object.keys(model.attributes || {})
+  }
+
+  return attributes
+    .filter((attr) => attr.startsWith(prefix))
+    .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

@@ -0,0 +1,71 @@
+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) => {
+      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/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 []
+}