@sailshq/language-server 0.1.0 → 0.2.0

package/SailsParser.js

@@ -1,5 +1,7 @@
 const fs = require('fs').promises
 const path = require('path')
+const acorn = require('acorn')
+const walk = require('acorn-walk')
 
 class SailsParser {
   constructor(rootDir) {
@@ -83,36 +85,21 @@ class SailsParser {
     const dir = path.join(this.rootDir, 'api', 'models')
     const models = {}
 
-    // Define Waterline static and chainable methods
     const STATIC_METHODS = [
-      {
-        name: 'find',
-        description: 'Retrieve all records matching criteria.'
-      },
+      { name: 'find', description: 'Retrieve all records matching criteria.' },
       {
         name: 'findOne',
         description: 'Retrieve a single record matching criteria.'
       },
-      {
-        name: 'create',
-        description: 'Create a new record.'
-      },
+      { name: 'create', description: 'Create a new record.' },
       {
         name: 'createEach',
         description: 'Create multiple new records in a batch.'
       },
-      {
-        name: 'update',
-        description: 'Update records matching criteria.'
-      },
-      {
-        name: 'destroy',
-        description: 'Delete records matching criteria.'
-      },
-      {
-        name: 'count',
-        description: 'Count records matching criteria.'
-      },
+      { name: 'update', description: 'Update records matching criteria.' },
+      { name: 'destroy', description: 'Delete records matching criteria.' },
+      { name: 'destroyOne', description: 'Delete a single record.' },
+      { name: 'count', description: 'Count records matching criteria.' },
       {
         name: 'replaceCollection',
         description: 'Replace all items in a collection association.'
@@ -129,85 +116,208 @@ class SailsParser {
         name: 'findOrCreate',
         description: 'Find a record or create it if it does not exist.'
       },
+      { name: 'stream', description: 'Stream results as they are found.' },
+      { name: 'sum', description: 'Calculate the sum of a numeric attribute.' },
+      { name: 'archive', description: 'Archive records instead of deleting.' },
+      { name: 'archiveOne', description: 'Archive a single record.' },
       {
-        name: 'findOrCreateEach',
-        description: 'Find or create multiple records in a batch.'
-      }
-    ]
-
-    const CHAINABLE_METHODS = [
-      {
-        name: 'where',
-        description: 'Filter records by criteria.'
-      },
-      {
-        name: 'limit',
-        description: 'Limit the number of records returned.'
+        name: 'validate',
+        description: 'Validate a record against its schema.'
       },
       {
-        name: 'skip',
-        description: 'Skip a number of records (for pagination).'
+        name: 'avg',
+        description: 'Calculate the average of a numeric attribute.'
       },
       {
-        name: 'sort',
-        description: 'Sort records by specified attributes.'
-      },
-      {
-        name: 'populate',
-        description: 'Populate associated records.'
-      },
-      {
-        name: 'select',
-        description: 'Select only specific attributes to return.'
-      },
-      {
-        name: 'omit',
-        description: 'Omit specific attributes from the result.'
-      },
-      {
-        name: 'meta',
-        description: 'Pass additional options to the query.'
-      },
-      {
-        name: 'decrypt',
-        description: 'Decrypt encrypted attributes in the result.'
+        name: 'getDatastore',
+        description: 'Get the datastore used by this model.'
       }
     ]
 
+    const CHAINABLE_METHODS = [
+      { name: 'where', description: 'Filter records by criteria.' },
+      { name: 'limit', description: 'Limit the number of records returned.' },
+      { name: 'skip', description: 'Skip a number of records.' },
+      { name: 'sort', description: 'Sort records by attributes.' },
+      { name: 'populate', description: 'Populate associated records.' },
+      { name: 'select', description: 'Select specific attributes.' },
+      { name: 'omit', description: 'Omit specific attributes.' },
+      { name: 'meta', description: 'Pass additional options.' },
+      { name: 'decrypt', description: 'Decrypt encrypted attributes.' },
+      { name: 'fetch', description: 'Return affected records.' },
+      { name: 'intercept', description: 'Intercept results with a function.' },
+      { name: 'eachRecord', description: 'Iterate over each record.' },
+      { name: 'toPromise', description: 'Return a promise for the results.' },
+      { name: 'catch', description: 'Handle errors in the query.' },
+      {
+        name: 'usingConnection',
+        description: 'Use a specific database connection.'
+      }
+    ]
+    const context = this
     if (!(await this.#directoryExists(dir))) return models
 
     const files = await fs.readdir(dir)
+
+    // Retrieve attributes from config/models.js
+    let defaultAttributes = {}
+    const modelsConfigPath = path.join(this.rootDir, 'config', 'models.js')
+    if (await this.#fileExists(modelsConfigPath)) {
+      try {
+        const configCode = await fs.readFile(modelsConfigPath, 'utf8')
+        const configAST = acorn.parse(configCode, {
+          ecmaVersion: 'latest',
+          sourceType: 'module'
+        })
+
+        walk.simple(configAST, {
+          AssignmentExpression(node) {
+            // Support: module.exports = { attributes: ... } and { models: { attributes: ... } }
+            if (
+              node.left.type === 'MemberExpression' &&
+              node.left.object.name === 'module' &&
+              node.left.property.name === 'exports' &&
+              node.right.type === 'ObjectExpression'
+            ) {
+              for (const prop of node.right.properties) {
+                if (
+                  prop.key?.name === 'attributes' &&
+                  prop.value?.type === 'ObjectExpression'
+                ) {
+                  defaultAttributes = context.#extractObjectLiteral(prop.value)
+                }
+                if (
+                  prop.key?.name === 'models' &&
+                  prop.value?.type === 'ObjectExpression'
+                ) {
+                  for (const inner of prop.value.properties) {
+                    if (
+                      inner.key?.name === 'attributes' &&
+                      inner.value?.type === 'ObjectExpression'
+                    ) {
+                      defaultAttributes = context.#extractObjectLiteral(
+                        inner.value
+                      )
+                    }
+                  }
+                }
+              }
+            }
+            // Support: module.exports.models = { attributes: ... }
+            if (
+              node.left.type === 'MemberExpression' &&
+              node.left.object.type === 'MemberExpression' &&
+              node.left.object.object.name === 'module' &&
+              node.left.object.property.name === 'exports' &&
+              node.left.property.name === 'models' &&
+              node.right.type === 'ObjectExpression'
+            ) {
+              for (const prop of node.right.properties) {
+                if (
+                  prop.key?.name === 'attributes' &&
+                  prop.value?.type === 'ObjectExpression'
+                ) {
+                  defaultAttributes = context.#extractObjectLiteral(prop.value)
+                }
+              }
+            }
+          }
+        })
+      } catch (err) {
+        console.error('Error parsing config/models.js', err)
+      }
+    }
+
     for (const file of files) {
       if (!file.endsWith('.js')) continue
 
       const name = file.slice(0, -3)
       const modelPath = path.join(dir, file)
+      let attributes = {}
+      const context = this
 
       try {
-        const model = require(modelPath)
-        const info = {
-          path: modelPath,
-          methods: STATIC_METHODS,
-          chainableMethods: CHAINABLE_METHODS,
-          attributes: { ...model.attributes }
-        }
-
-        const modelsConfigPath = path.join(this.rootDir, 'config', 'models.js')
-
-        if (await fs.stat(modelsConfigPath)) {
-          const modelsConfig = require(modelsConfigPath)
-          if (modelsConfig.attributes) {
-            info.attributes = { ...modelsConfig.attributes, ...info.attributes }
+        const code = await fs.readFile(modelPath, 'utf8')
+        const ast = acorn.parse(code, {
+          ecmaVersion: 'latest',
+          sourceType: 'module'
+        })
+
+        walk.simple(ast, {
+          AssignmentExpression(node) {
+            // Handle: module.exports = { attributes: ... }
+            if (
+              node.left.type === 'MemberExpression' &&
+              node.left.object.name === 'module' &&
+              node.left.property.name === 'exports' &&
+              node.right.type === 'ObjectExpression'
+            ) {
+              for (const prop of node.right.properties) {
+                if (
+                  prop.key?.name === 'attributes' &&
+                  prop.value?.type === 'ObjectExpression'
+                ) {
+                  attributes = context.#extractObjectLiteral(prop.value)
+                }
+              }
+            }
+            // Legacy: module.exports.attributes = { ... }
+            else if (
+              node.left.type === 'MemberExpression' &&
+              node.left.object.type === 'MemberExpression' &&
+              node.left.object.object.name === 'module' &&
+              node.left.object.property.name === 'exports' &&
+              node.left.property.name === 'attributes' &&
+              node.right.type === 'ObjectExpression'
+            ) {
+              attributes = context.#extractObjectLiteral(node.right)
+            }
+          },
+          ExportDefaultDeclaration(node) {
+            if (node.declaration.type === 'ObjectExpression') {
+              for (const prop of node.declaration.properties) {
+                if (
+                  prop.key?.name === 'attributes' &&
+                  prop.value?.type === 'ObjectExpression'
+                ) {
+                  attributes = context.#extractObjectLiteral(prop.value)
+                }
+              }
+            }
           }
-        }
-        models[name] = info
+        })
       } catch (err) {
-        console.error(`Error requiring model: ${file}`, err)
+        console.error(`Error parsing model: ${file}`, err)
+        continue
+      }
+
+      // Merge defaultAttributes first, then model attributes (model overrides default)
+      const mergedAttributes = {}
+      for (const key of Object.keys(defaultAttributes)) {
+        mergedAttributes[key] = defaultAttributes[key]
+      }
+      for (const key of Object.keys(attributes)) {
+        mergedAttributes[key] = attributes[key]
+      }
+      models[name] = {
+        path: modelPath,
+        methods: STATIC_METHODS,
+        chainableMethods: CHAINABLE_METHODS,
+        attributes: mergedAttributes
       }
     }
+
     return models
   }
 
+  async #fileExists(filePath) {
+    try {
+      const stat = await fs.stat(filePath)
+      return stat.isFile()
+    } catch {
+      return false
+    }
+  }
   async #parseViews() {
     const dir = path.join(this.rootDir, 'views')
     const views = {}
@@ -303,7 +413,114 @@ class SailsParser {
                 break
               }
             }
-            helpers[name] = { path: fullPath, fnLine }
+            // Extract inputs and description using acorn
+            let inputs = {}
+            let description = undefined
+            const context = this
+            try {
+              const ast = acorn.parse(content, {
+                ecmaVersion: 'latest',
+                sourceType: 'module'
+              })
+              walk.simple(ast, {
+                AssignmentExpression(node) {
+                  // Only handle: module.exports = { ... }
+                  if (
+                    node.left.type === 'MemberExpression' &&
+                    node.left.object.name === 'module' &&
+                    node.left.property.name === 'exports' &&
+                    node.right.type === 'ObjectExpression'
+                  ) {
+                    for (const prop of node.right.properties) {
+                      if (
+                        prop.key &&
+                        prop.key.name === 'inputs' &&
+                        prop.value.type === 'ObjectExpression'
+                      ) {
+                        inputs = context.#extractObjectLiteral(prop.value)
+                      }
+                      if (
+                        prop.key &&
+                        prop.key.name === 'description' &&
+                        (prop.value.type === 'Literal' ||
+                          prop.value.type === 'TemplateLiteral')
+                      ) {
+                        if (prop.value.type === 'Literal') {
+                          description = prop.value.value
+                        } else if (prop.value.type === 'TemplateLiteral') {
+                          description = prop.value.quasis
+                            .map((q) => q.value.cooked)
+                            .join('')
+                        }
+                      }
+                    }
+                  }
+                },
+                ExportDefaultDeclaration(node) {
+                  // Handle: export default { ... }
+                  if (
+                    node.declaration &&
+                    node.declaration.type === 'ObjectExpression'
+                  ) {
+                    for (const prop of node.declaration.properties) {
+                      if (
+                        prop.key &&
+                        prop.key.name === 'inputs' &&
+                        prop.value.type === 'ObjectExpression'
+                      ) {
+                        inputs = context.#extractObjectLiteral(prop.value)
+                      }
+                      if (
+                        prop.key &&
+                        prop.key.name === 'description' &&
+                        (prop.value.type === 'Literal' ||
+                          prop.value.type === 'TemplateLiteral')
+                      ) {
+                        if (prop.value.type === 'Literal') {
+                          description = prop.value.value
+                        } else if (prop.value.type === 'TemplateLiteral') {
+                          description = prop.value.quasis
+                            .map((q) => q.value.cooked)
+                            .join('')
+                        }
+                      }
+                    }
+                  }
+                }
+              })
+            } catch (e) {}
+            // Fallback: regex extract inputs/description if still empty
+            if (!inputs || Object.keys(inputs).length === 0) {
+              const match = content.match(/inputs\s*:\s*\{([\s\S]*?)\n\s*\}/m)
+              if (match) {
+                try {
+                  // Try to parse as JS object
+                  const fakeObj = `({${match[1]}})`
+                  const ast = acorn.parse(fakeObj, { ecmaVersion: 'latest' })
+                  let obj = {}
+                  walk.simple(ast, {
+                    ObjectExpression(node) {
+                      if (!obj || Object.keys(obj).length === 0) {
+                        obj = context.#extractObjectLiteral(node)
+                      }
+                    }
+                  })
+                  if (obj && Object.keys(obj).length > 0) {
+                    inputs = obj
+                  }
+                } catch (e) {}
+              }
+            }
+            if (!description) {
+              // Try to extract description: '...' or description: "..."
+              const descMatch = content.match(
+                /description\s*:\s*(['"])([\s\S]*?)\1/
+              )
+              if (descMatch) {
+                description = descMatch[2]
+              }
+            }
+            helpers[name] = { path: fullPath, fnLine, inputs, description }
           }
         }
       }
@@ -312,6 +529,38 @@ class SailsParser {
     return helpers
   }
 
+  #extractObjectLiteral(node) {
+    if (node.type !== 'ObjectExpression') return undefined
+    const obj = {}
+    for (const prop of node.properties) {
+      if (prop.type === 'Property') {
+        const key =
+          prop.key.type === 'Identifier' ? prop.key.name : prop.key.value
+        let value
+        if (prop.value.type === 'ObjectExpression') {
+          value = this.#extractObjectLiteral(prop.value)
+        } else if (prop.value.type === 'ArrayExpression') {
+          value = prop.value.elements.map((el) =>
+            el.type === 'ObjectExpression'
+              ? this.#extractObjectLiteral(el)
+              : el.type === 'Literal'
+                ? el.value
+                : el.type === 'Identifier'
+                  ? el.name
+                  : undefined
+          )
+        } else if (prop.value.type === 'Literal') {
+          value = prop.value.value
+        } else if (prop.value.type === 'Identifier') {
+          value = prop.value.name
+        } else {
+          value = undefined
+        }
+        obj[key] = value
+      }
+    }
+    return obj
+  }
   #getDataTypes() {
     return [
       {

package/completions/data-types-completion.js

@@ -15,14 +15,15 @@ module.exports = function dataTypesCompletion(document, position, typeMap) {
   const offset = document.offsetAt(position)
   const before = text.substring(0, offset)
 
-  const match = before.match(/type\s*:\s*['"]([a-z]*)$/i)
+  // 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[1]
+  const prefix = match[2] || ''
 
   const contextText = before.toLowerCase()
-  const inAttributes = /attributes\s*:\s*{[^}]*$/.test(contextText)
-  const inInputs = /inputs\s*:\s*{[^}]*$/.test(contextText)
+  const inAttributes = /attributes\s*:\s*{([\s\S]*)$/.test(contextText)
+  const inInputs = /inputs\s*:\s*{([\s\S]*)$/.test(contextText)
 
   if (!(inAttributes || inInputs)) return []
 
@@ -31,7 +32,7 @@ module.exports = function dataTypesCompletion(document, position, typeMap) {
     .map(({ type, description }) => ({
       label: type,
       kind: lsp.CompletionItemKind.TypeParameter,
-      detail: 'Validation type',
+      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 + '.'
+        }
+      }
+    })
+}