@sanity/groq-lsp 0.0.1

package/dist/chunk-UOIHOMN2.js

@@ -0,0 +1,703 @@
+// src/schema/loader.ts
+import { readFileSync, existsSync, statSync, watch } from "fs";
+import { join } from "path";
+var SCHEMA_CANDIDATES = [
+  "schema.json",
+  "sanity.schema.json",
+  ".sanity/schema.json",
+  "studio/schema.json"
+];
+var SchemaLoader = class {
+  state = {};
+  watcher = null;
+  onChangeCallback = null;
+  /**
+   * Load schema from a specific path
+   */
+  loadFromPath(schemaPath) {
+    try {
+      if (!existsSync(schemaPath)) {
+        this.state = {
+          path: schemaPath,
+          error: `Schema file not found: ${schemaPath}`
+        };
+        return this.state;
+      }
+      const content = readFileSync(schemaPath, "utf-8");
+      const schema = JSON.parse(content);
+      const stats = statSync(schemaPath);
+      this.state = {
+        schema,
+        path: schemaPath,
+        lastModified: stats.mtimeMs
+      };
+      return this.state;
+    } catch (e) {
+      this.state = {
+        path: schemaPath,
+        error: `Failed to load schema: ${e instanceof Error ? e.message : String(e)}`
+      };
+      return this.state;
+    }
+  }
+  /**
+   * Auto-discover schema file in workspace
+   */
+  discoverSchema(workspaceRoot) {
+    for (const candidate of SCHEMA_CANDIDATES) {
+      const candidatePath = join(workspaceRoot, candidate);
+      if (existsSync(candidatePath)) {
+        return this.loadFromPath(candidatePath);
+      }
+    }
+    this.state = {
+      error: "No schema.json found. Generate with: npx sanity schema extract"
+    };
+    return this.state;
+  }
+  /**
+   * Get the current schema state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the loaded schema (if any)
+   */
+  getSchema() {
+    return this.state.schema;
+  }
+  /**
+   * Check if schema needs reloading (file changed)
+   */
+  needsReload() {
+    if (!this.state.path || !existsSync(this.state.path)) {
+      return false;
+    }
+    try {
+      const stats = statSync(this.state.path);
+      return stats.mtimeMs !== this.state.lastModified;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Reload schema if the file has changed
+   */
+  reloadIfNeeded() {
+    if (this.needsReload() && this.state.path) {
+      this.loadFromPath(this.state.path);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Start watching the schema file for changes
+   */
+  startWatching(onChange) {
+    this.onChangeCallback = onChange;
+    if (!this.state.path || !existsSync(this.state.path)) {
+      return;
+    }
+    try {
+      this.watcher = watch(this.state.path, (eventType) => {
+        if (eventType === "change" && this.state.path) {
+          this.loadFromPath(this.state.path);
+          this.onChangeCallback?.(this.state.schema);
+        }
+      });
+    } catch (e) {
+      console.error(`Failed to watch schema file: ${e}`);
+    }
+  }
+  /**
+   * Stop watching the schema file
+   */
+  stopWatching() {
+    this.watcher?.close();
+    this.watcher = null;
+    this.onChangeCallback = null;
+  }
+  /**
+   * Clear the loaded schema
+   */
+  clear() {
+    this.stopWatching();
+    this.state = {};
+  }
+};
+var defaultLoader = null;
+function getSchemaLoader() {
+  if (!defaultLoader) {
+    defaultLoader = new SchemaLoader();
+  }
+  return defaultLoader;
+}
+
+// src/utils/groq-extractor.ts
+function extractQueries(content, languageId) {
+  switch (languageId) {
+    case "groq":
+      return extractFromGroqFile(content);
+    case "typescript":
+    case "typescriptreact":
+    case "javascript":
+    case "javascriptreact":
+      return extractFromJsTs(content);
+    default:
+      return { queries: [], errors: [] };
+  }
+}
+function extractFromGroqFile(content) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return { queries: [], errors: [] };
+  }
+  return {
+    queries: [
+      {
+        query: trimmed,
+        start: content.indexOf(trimmed),
+        end: content.indexOf(trimmed) + trimmed.length,
+        line: 0,
+        column: 0
+      }
+    ],
+    errors: []
+  };
+}
+function extractFromJsTs(content) {
+  const queries = [];
+  const errors = [];
+  const groqTagRegex = /\bgroq\s*`([^`]*)`/g;
+  let match;
+  while ((match = groqTagRegex.exec(content)) !== null) {
+    const queryContent = match[1];
+    if (queryContent === void 0) continue;
+    const fullMatchStart = match.index;
+    const queryStart = fullMatchStart + match[0].indexOf("`") + 1;
+    const beforeMatch = content.slice(0, queryStart);
+    const lines = beforeMatch.split("\n");
+    const line = lines.length - 1;
+    const column = lines[lines.length - 1]?.length ?? 0;
+    queries.push({
+      query: queryContent,
+      start: queryStart,
+      end: queryStart + queryContent.length,
+      line,
+      column
+    });
+  }
+  return { queries, errors };
+}
+function findQueryAtOffset(queries, offset) {
+  return queries.find((q) => offset >= q.start && offset <= q.end);
+}
+function offsetToQueryPosition(query, documentOffset) {
+  return documentOffset - query.start;
+}
+
+// src/capabilities/diagnostics.ts
+import { lint } from "@sanity/groq-lint";
+function computeQueryDiagnostics(query, options = {}) {
+  const result = lint(query.query, options.schema ? { schema: options.schema } : void 0);
+  if (result.parseError) {
+    const diagnostic = {
+      range: {
+        start: { line: query.line, character: query.column },
+        end: { line: query.line, character: query.column + query.query.length }
+      },
+      severity: 1,
+      // Error
+      source: "groq",
+      message: `Parse error: ${result.parseError}`
+    };
+    return {
+      query,
+      diagnostics: [diagnostic],
+      parseError: result.parseError
+    };
+  }
+  const diagnostics = result.findings.map((finding) => findingToDiagnostic(finding, query));
+  return { query, diagnostics };
+}
+function computeDocumentDiagnostics(queries, options = {}) {
+  const allDiagnostics = [];
+  for (const query of queries) {
+    const result = computeQueryDiagnostics(query, options);
+    allDiagnostics.push(...result.diagnostics);
+  }
+  return allDiagnostics;
+}
+function findingToDiagnostic(finding, query) {
+  const range = findingToRange(finding, query);
+  const diagnostic = {
+    range,
+    severity: severityToLsp(finding.severity),
+    source: "groq",
+    code: finding.ruleId,
+    message: finding.message
+  };
+  if (finding.help) {
+    diagnostic.message += `
+
+Help: ${finding.help}`;
+  }
+  return diagnostic;
+}
+function findingToRange(finding, query) {
+  if (finding.span) {
+    const startLine = query.line + finding.span.start.line - 1;
+    const endLine = query.line + finding.span.end.line - 1;
+    const startChar = finding.span.start.line === 1 ? query.column + finding.span.start.column - 1 : finding.span.start.column - 1;
+    const endChar = finding.span.end.line === 1 ? query.column + finding.span.end.column - 1 : finding.span.end.column - 1;
+    return {
+      start: { line: startLine, character: startChar },
+      end: { line: endLine, character: endChar }
+    };
+  }
+  return {
+    start: { line: query.line, character: query.column },
+    end: { line: query.line, character: query.column + query.query.length }
+  };
+}
+function severityToLsp(severity) {
+  switch (severity) {
+    case "error":
+      return 1;
+    // DiagnosticSeverity.Error
+    case "warning":
+      return 2;
+    // DiagnosticSeverity.Warning
+    case "info":
+      return 3;
+    // DiagnosticSeverity.Information
+    default:
+      return 4;
+  }
+}
+function positionToQueryOffset(position, query, _documentLines) {
+  const queryLines = query.query.split("\n");
+  const queryEndLine = query.line + queryLines.length - 1;
+  if (position.line < query.line || position.line > queryEndLine) {
+    return null;
+  }
+  let offset = 0;
+  for (let i = query.line; i < position.line; i++) {
+    const lineInQuery2 = i - query.line;
+    if (lineInQuery2 < queryLines.length) {
+      offset += (queryLines[lineInQuery2]?.length ?? 0) + 1;
+    }
+  }
+  const lineInQuery = position.line - query.line;
+  if (lineInQuery === 0) {
+    offset += position.character - query.column;
+  } else {
+    offset += position.character;
+  }
+  if (offset < 0 || offset > query.query.length) {
+    return null;
+  }
+  return offset;
+}
+
+// src/capabilities/hover.ts
+import { parse, typeEvaluate } from "groq-js";
+function getHoverInfo(query, positionInQuery, options = {}) {
+  try {
+    const ast = parse(query.query);
+    const nodeInfo = findNodeAtPosition(ast, positionInQuery, query.query);
+    if (!nodeInfo) {
+      return null;
+    }
+    let typeInfo = null;
+    if (options.schema) {
+      try {
+        const resultType = typeEvaluate(ast, options.schema);
+        typeInfo = typeNodeToInfo(resultType, nodeInfo.text);
+      } catch {
+      }
+    }
+    const content = buildHoverContent(nodeInfo, typeInfo);
+    if (!content) {
+      return null;
+    }
+    return {
+      contents: content
+    };
+  } catch {
+    return null;
+  }
+}
+function findNodeAtPosition(_ast, position, queryText) {
+  const { word, context } = extractWordAtPosition(queryText, position);
+  if (!word) {
+    return null;
+  }
+  if (context === "filter" && word.startsWith("_type")) {
+    return {
+      type: "filter",
+      text: word,
+      documentation: "Filters documents by their type"
+    };
+  }
+  if (word.startsWith("_")) {
+    return {
+      type: "system-field",
+      text: word,
+      documentation: getSystemFieldDoc(word)
+    };
+  }
+  if (word === "->") {
+    return {
+      type: "dereference",
+      text: "->",
+      documentation: "Dereferences a reference to fetch the referenced document"
+    };
+  }
+  const funcDoc = getGroqFunctionDoc(word);
+  if (funcDoc) {
+    return {
+      type: "function",
+      text: word,
+      documentation: funcDoc
+    };
+  }
+  return {
+    type: "field",
+    text: word
+  };
+}
+function extractWordAtPosition(text, position) {
+  let start = position;
+  let end = position;
+  while (start > 0 && isWordChar(text[start - 1])) {
+    start--;
+  }
+  while (end < text.length && isWordChar(text[end])) {
+    end++;
+  }
+  const word = text.slice(start, end);
+  const before = text.slice(0, start).trim();
+  let context = "unknown";
+  if (before.endsWith("[")) {
+    context = "filter";
+  } else if (before.endsWith("{") || before.endsWith(",")) {
+    context = "projection";
+  } else if (before.endsWith("->")) {
+    context = "dereference";
+  }
+  return { word: word || null, context };
+}
+function isWordChar(char) {
+  if (!char) return false;
+  return /[a-zA-Z0-9_]/.test(char);
+}
+function getSystemFieldDoc(field) {
+  const docs = {
+    _id: "Unique document identifier",
+    _type: "Document type name",
+    _rev: "Document revision (changes on every update)",
+    _createdAt: "Timestamp when the document was created",
+    _updatedAt: "Timestamp when the document was last updated",
+    _key: "Array item key (unique within the array)",
+    _ref: "Reference target document ID",
+    _weak: "Whether this is a weak reference"
+  };
+  return docs[field] ?? `System field: ${field}`;
+}
+function getGroqFunctionDoc(name) {
+  const docs = {
+    count: "count(array) - Returns the number of items in an array",
+    defined: "defined(value) - Returns true if the value is not null",
+    coalesce: "coalesce(a, b, ...) - Returns the first non-null value",
+    select: "select(conditions) - Returns value based on conditions",
+    length: "length(string|array) - Returns the length",
+    lower: "lower(string) - Converts string to lowercase",
+    upper: "upper(string) - Converts string to uppercase",
+    now: "now() - Returns the current timestamp",
+    round: "round(number, precision?) - Rounds a number",
+    string: "string(value) - Converts value to string",
+    references: "references(id) - Returns true if document references the ID",
+    dateTime: "dateTime(string) - Parses an ISO 8601 date string",
+    boost: "boost(condition, value) - Boosts score in text search",
+    score: "score(conditions) - Returns relevance score",
+    order: "order(field, direction?) - Sorts results",
+    pt: "pt::text(blocks) - Extracts plain text from Portable Text",
+    geo: "geo::distance(a, b) - Calculates distance between points",
+    math: "math::sum(array), math::avg(array), etc. - Math operations",
+    array: "array::unique(arr), array::compact(arr) - Array operations",
+    sanity: "sanity::projectId(), sanity::dataset() - Sanity project info"
+  };
+  return docs[name] ?? null;
+}
+function typeNodeToInfo(typeNode, fieldName) {
+  const typeStr = formatTypeNode(typeNode);
+  return {
+    type: typeStr,
+    schemaType: fieldName
+  };
+}
+function formatTypeNode(node) {
+  switch (node.type) {
+    case "null":
+      return "null";
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return node.value !== void 0 ? `"${node.value}"` : "string";
+    case "array":
+      return `array<${formatTypeNode(node.of)}>`;
+    case "object":
+      return "object";
+    case "union":
+      if (node.of.length <= 3) {
+        return node.of.map(formatTypeNode).join(" | ");
+      }
+      return `union<${node.of.length} types>`;
+    case "unknown":
+      return "unknown";
+    case "inline":
+      return node.name;
+    default:
+      return "unknown";
+  }
+}
+function buildHoverContent(nodeInfo, typeInfo) {
+  const parts = [];
+  if (typeInfo) {
+    parts.push("```groq");
+    parts.push(`${nodeInfo.text}: ${typeInfo.type}`);
+    parts.push("```");
+  } else {
+    parts.push(`**${nodeInfo.text}** (${nodeInfo.type})`);
+  }
+  if (nodeInfo.documentation) {
+    parts.push("");
+    parts.push(nodeInfo.documentation);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return {
+    kind: "markdown",
+    value: parts.join("\n")
+  };
+}
+
+// src/capabilities/completion.ts
+function getCompletions(query, positionInQuery, options = {}) {
+  const context = analyzeCompletionContext(query.query, positionInQuery);
+  switch (context.kind) {
+    case "type-value":
+      return getTypeValueCompletions(options.schema, context.prefix);
+    case "field":
+      return getFieldCompletions(options.schema, context.documentType, context.prefix);
+    case "function":
+      return getFunctionCompletions(context.prefix);
+    default:
+      return [
+        ...getFieldCompletions(options.schema, context.documentType, context.prefix),
+        ...getFunctionCompletions(context.prefix),
+        ...getSystemFieldCompletions(context.prefix)
+      ];
+  }
+}
+function analyzeCompletionContext(query, position) {
+  const before = query.slice(0, position);
+  const prefix = extractPrefix(before);
+  if (/_type\s*[=!]=\s*["']$/.test(before) || /_type\s*[=!]=\s*["'][a-zA-Z0-9]*$/.test(before)) {
+    return { kind: "type-value", prefix: prefix.replace(/["']/g, "") };
+  }
+  const typeMatch = before.match(/_type\s*==\s*["'](\w+)["']/i);
+  const documentType = typeMatch?.[1];
+  if (/\.\s*\w*$/.test(before) || /{\s*[\w,\s]*$/.test(before)) {
+    return { kind: "field", documentType, prefix };
+  }
+  if (/[a-z]+$/.test(prefix) && !/->/.test(before.slice(-10))) {
+    return { kind: "function", prefix };
+  }
+  return { kind: "unknown", documentType, prefix };
+}
+function extractPrefix(text) {
+  const match = text.match(/[a-zA-Z_][a-zA-Z0-9_]*$/);
+  return match?.[0] ?? "";
+}
+function getTypeValueCompletions(schema, prefix) {
+  if (!schema || !Array.isArray(schema)) {
+    return [];
+  }
+  return schema.filter(
+    (type) => type.type === "document" && type.name.toLowerCase().includes(prefix.toLowerCase())
+  ).map((type) => ({
+    label: type.name,
+    kind: 12,
+    // Value
+    detail: "Document type",
+    insertText: type.name,
+    documentation: `Document type: ${type.name}`
+  }));
+}
+function getFieldCompletions(schema, documentType, prefix) {
+  const completions = [];
+  completions.push(...getSystemFieldCompletions(prefix));
+  if (schema && Array.isArray(schema) && documentType) {
+    const typeSchema = schema.find((t) => t.name === documentType);
+    if (typeSchema && "attributes" in typeSchema && typeSchema.attributes) {
+      for (const [fieldName, _fieldDef] of Object.entries(typeSchema.attributes)) {
+        if (fieldName.toLowerCase().includes(prefix.toLowerCase())) {
+          completions.push({
+            label: fieldName,
+            kind: 5,
+            // Field
+            detail: `Field on ${documentType}`,
+            insertText: fieldName
+          });
+        }
+      }
+    }
+  }
+  return completions;
+}
+function getSystemFieldCompletions(prefix) {
+  const systemFields = [
+    { name: "_id", doc: "Unique document identifier" },
+    { name: "_type", doc: "Document type name" },
+    { name: "_rev", doc: "Document revision" },
+    { name: "_createdAt", doc: "Creation timestamp" },
+    { name: "_updatedAt", doc: "Last update timestamp" },
+    { name: "_key", doc: "Array item key" },
+    { name: "_ref", doc: "Reference target ID" }
+  ];
+  return systemFields.filter((f) => f.name.toLowerCase().includes(prefix.toLowerCase())).map((f) => ({
+    label: f.name,
+    kind: 5,
+    // Field
+    detail: "System field",
+    documentation: f.doc,
+    insertText: f.name
+  }));
+}
+function getFunctionCompletions(prefix) {
+  const functions = [
+    { name: "count", sig: "count(array)", doc: "Returns the number of items" },
+    { name: "defined", sig: "defined(value)", doc: "Returns true if value is not null" },
+    { name: "coalesce", sig: "coalesce(a, b, ...)", doc: "Returns first non-null value" },
+    { name: "select", sig: "select(cond => val, ...)", doc: "Conditional value selection" },
+    { name: "length", sig: "length(str|arr)", doc: "Returns length" },
+    { name: "lower", sig: "lower(string)", doc: "Converts to lowercase" },
+    { name: "upper", sig: "upper(string)", doc: "Converts to uppercase" },
+    { name: "now", sig: "now()", doc: "Current timestamp" },
+    { name: "round", sig: "round(num, precision?)", doc: "Rounds a number" },
+    { name: "string", sig: "string(value)", doc: "Converts to string" },
+    { name: "references", sig: "references(id)", doc: "Checks if document references ID" },
+    { name: "dateTime", sig: "dateTime(string)", doc: "Parses ISO 8601 date" },
+    { name: "order", sig: "order(field, dir?)", doc: "Sorts results" },
+    { name: "score", sig: "score(...conditions)", doc: "Relevance scoring" },
+    { name: "boost", sig: "boost(cond, value)", doc: "Boosts search score" },
+    // Namespace functions
+    { name: "pt::text", sig: "pt::text(blocks)", doc: "Extract text from Portable Text" },
+    { name: "geo::distance", sig: "geo::distance(a, b)", doc: "Distance between points" },
+    { name: "math::sum", sig: "math::sum(array)", doc: "Sum of numbers" },
+    { name: "math::avg", sig: "math::avg(array)", doc: "Average of numbers" },
+    { name: "math::min", sig: "math::min(array)", doc: "Minimum value" },
+    { name: "math::max", sig: "math::max(array)", doc: "Maximum value" },
+    { name: "array::unique", sig: "array::unique(arr)", doc: "Remove duplicates" },
+    { name: "array::compact", sig: "array::compact(arr)", doc: "Remove nulls" },
+    { name: "array::join", sig: "array::join(arr, sep)", doc: "Join into string" },
+    { name: "string::split", sig: "string::split(str, sep)", doc: "Split string" },
+    { name: "string::startsWith", sig: "string::startsWith(str, prefix)", doc: "Check prefix" },
+    { name: "sanity::projectId", sig: "sanity::projectId()", doc: "Current project ID" },
+    { name: "sanity::dataset", sig: "sanity::dataset()", doc: "Current dataset" }
+  ];
+  return functions.filter((f) => f.name.toLowerCase().includes(prefix.toLowerCase())).map((f) => ({
+    label: f.name,
+    kind: 3,
+    // Function
+    detail: f.sig,
+    documentation: f.doc,
+    insertText: f.name.includes("::") ? f.name : `${f.name}($1)`,
+    insertTextFormat: 2
+    // Snippet
+  }));
+}
+function getCompletionTriggerCharacters() {
+  return [".", '"', "'", "[", "{", ":"];
+}
+
+// src/capabilities/formatting.ts
+async function formatQuery(query, options = {}) {
+  try {
+    const prettier = await import("prettier");
+    const groqPlugin = await import("prettier-plugin-groq");
+    const formatted = await prettier.format(query.query, {
+      parser: "groq",
+      plugins: [groqPlugin.default ?? groqPlugin],
+      tabWidth: options.tabSize ?? 2,
+      useTabs: !(options.insertSpaces ?? true),
+      printWidth: options.printWidth ?? 80
+    });
+    const trimmedFormatted = formatted.trimEnd();
+    if (trimmedFormatted === query.query) {
+      return [];
+    }
+    const range = queryToRange(query);
+    return [
+      {
+        range,
+        newText: trimmedFormatted
+      }
+    ];
+  } catch (error) {
+    console.error("Formatting failed:", error);
+    return [];
+  }
+}
+async function formatDocument(queries, _documentContent, options = {}) {
+  const edits = [];
+  const sortedQueries = [...queries].sort((a, b) => b.start - a.start);
+  for (const query of sortedQueries) {
+    const queryEdits = await formatQuery(query, options);
+    edits.push(...queryEdits);
+  }
+  return edits;
+}
+function queryToRange(query) {
+  const lines = query.query.split("\n");
+  const endLine = query.line + lines.length - 1;
+  const endChar = lines.length === 1 ? query.column + query.query.length : lines[lines.length - 1]?.length ?? 0;
+  return {
+    start: { line: query.line, character: query.column },
+    end: { line: endLine, character: endChar }
+  };
+}
+async function formatGroqFile(content, options = {}) {
+  const query = {
+    query: content.trim(),
+    start: 0,
+    end: content.length,
+    line: 0,
+    column: 0
+  };
+  return formatQuery(query, options);
+}
+
+export {
+  SchemaLoader,
+  getSchemaLoader,
+  extractQueries,
+  findQueryAtOffset,
+  offsetToQueryPosition,
+  computeQueryDiagnostics,
+  computeDocumentDiagnostics,
+  positionToQueryOffset,
+  getHoverInfo,
+  getCompletions,
+  getCompletionTriggerCharacters,
+  formatQuery,
+  formatDocument,
+  formatGroqFile
+};
+//# sourceMappingURL=chunk-UOIHOMN2.js.map