Editor Integrations for Geode GQL

Modern development workflows demand sophisticated editor support for productivity, code quality, and developer experience. Geode provides comprehensive editor integrations through Language Server Protocol (LSP) implementations, syntax highlighting packages, intelligent auto-completion, real-time diagnostics, and query execution capabilities across all major editors and IDEs.

Whether you prefer Visual Studio Code, Neovim, classic Vim, Emacs, JetBrains IDEs, Sublime Text, or any LSP-compatible editor, Geode’s tooling ecosystem ensures you have the rich development experience developers expect from enterprise database platforms.

This guide provides an overview of available editor integrations, common features, installation approaches, and guidance on choosing the right tools for your workflow.

Available Integrations Share link

Visual Studio Code Share link

The most feature-rich integration with full graphical support:

Installation:

code --install-extension geodedb.geode-gql

Best For: Developers who want a full-featured GUI experience with graph visualization and integrated debugging.

Detailed VS Code Guide

Neovim Share link

Modern, Lua-based integration with native LSP support:

Installation:

-- lazy.nvim
{ "geodedb/geode.nvim", dependencies = { "nvim-lspconfig" } }

Best For: Developers who prefer modal editing, terminal workflows, and extensive customization through Lua.

Detailed Neovim Guide

Vim Share link

Classic Vim support with omni-completion and ALE integration:

Installation:

Plug 'geodedb/vim-geode-gql'

Best For: Traditional Vim users who prefer stability and broad compatibility.

Detailed Vim Guide

JetBrains IDEs (IntelliJ, DataGrip) Share link

Professional IDE integration with database tooling:

Installation: Settings → Plugins → Search “Geode GQL”

Best For: Teams already using JetBrains IDEs who want integrated database tooling.

Emacs Share link

Emacs integration via lsp-mode:

Installation:

(use-package geode-gql-mode
  :ensure t
  :mode "\\.gql\\'"
  :hook (geode-gql-mode . lsp))

Best For: Emacs users who want consistent LSP integration.

Sublime Text Share link

Lightweight integration via LSP package:

Installation: Package Control → Install “Geode GQL”

Best For: Users who prefer a lightweight, fast editor.

Helix Share link

Modern terminal editor with built-in LSP:

Configuration:

# ~/.config/helix/languages.toml
[[language]]
name = "gql"
language-server = { command = "geode", args = ["lsp", "--stdio"] }

Best For: Users exploring modern terminal-based editors.

Language Server Protocol (LSP) Share link

Overview Share link

Geode implements the Language Server Protocol, enabling consistent language intelligence across all LSP-compatible editors. The LSP provides:

• Syntax Highlighting: Context-aware colorization
• Auto-Completion: Keywords, labels, properties, functions
• Diagnostics: Errors, warnings, hints
• Hover Information: Documentation on hover
• Go to Definition: Navigate to bindings
• Find References: Locate all usages
• Rename Symbol: Rename across queries
• Code Formatting: Automatic query formatting
• Signature Help: Function parameter hints

Starting the Language Server Share link

# Standard stdio mode (recommended)
geode lsp --stdio

# TCP socket mode (for remote editing)
geode lsp --listen 127.0.0.1:5007

# With debug logging
geode lsp --stdio --log-level debug --log-file /tmp/geode-lsp.log

LSP Capabilities Share link

{
  "capabilities": {
    "textDocumentSync": {
      "openClose": true,
      "change": 2,
      "save": { "includeText": true }
    },
    "completionProvider": {
      "triggerCharacters": [".", ":", "(", "[", " "],
      "resolveProvider": true
    },
    "hoverProvider": true,
    "definitionProvider": true,
    "referencesProvider": true,
    "documentFormattingProvider": true,
    "renameProvider": { "prepareProvider": true },
    "signatureHelpProvider": {
      "triggerCharacters": ["(", ","]
    },
    "diagnosticProvider": {
      "interFileDependencies": false,
      "workspaceDiagnostics": false
    }
  }
}

Connecting to Database Share link

The LSP server connects to a Geode database for schema introspection and validation:

// LSP initialization options
{
  "connection": {
    "host": "localhost",
    "port": 3141,
    "database": "default",
    "tls": false
  },
  "diagnostics": {
    "enabled": true,
    "validateLabels": true,
    "validateProperties": true,
    "validateRelationships": true
  }
}

Common Features Share link

Syntax Highlighting Share link

All integrations provide GQL syntax highlighting:

-- Keywords in keyword color
MATCH (user:User)-[:FOLLOWS]->(friend:User)
WHERE user.active = true
  AND user.created_at > datetime('2024-01-01')
RETURN friend.name AS friend_name,
       COUNT(*) AS mutual_friends
GROUP BY friend.name
ORDER BY mutual_friends DESC
LIMIT 10;

-- Different elements highlighted distinctly:
-- - Keywords: MATCH, WHERE, RETURN, etc.
-- - Labels: :User
-- - Relationships: :FOLLOWS
-- - Properties: .active, .created_at, .name
-- - Functions: datetime(), COUNT()
-- - Strings: '2024-01-01'
-- - Numbers: 10
-- - Comments: -- this line

Auto-Completion Share link

Context-aware suggestions:

-- After typing "MATCH (u:"
-- Completions: All labels from schema (User, Product, Order, etc.)

-- After typing "WHERE u."
-- Completions: Properties of User (id, name, email, active, etc.)

-- After typing "-[:"
-- Completions: Relationship types (FOLLOWS, PURCHASED, REVIEWED, etc.)

-- After typing "RETURN UPPER("
-- Completions: Function signature with parameter info

Real-Time Diagnostics Share link

Errors and warnings as you type:

-- Syntax Error
MATCH (u:User)
WHER u.email = 'test@example.com'  -- Error: Unknown keyword 'WHER'
RETURN u;

-- Unknown Label Warning
MATCH (u:UnknownLabel)  -- Warning: Label not found in schema
RETURN u;

-- Property Warning
MATCH (u:User)
WHERE u.nonexistent = 'value'  -- Warning: Property not in schema
RETURN u;

-- Type Error
MATCH (u:User)
WHERE u.age + 'string'  -- Error: Cannot add Integer + String
RETURN u;

Query Execution Share link

Execute queries without leaving the editor:

Code Formatting Share link

Format queries for consistency:

-- Before formatting
match(u:User)-[:FOLLOWS]->(f) where u.active=true return f.name,count(*) as cnt group by f.name order by cnt desc;

-- After formatting
MATCH (u:User)-[:FOLLOWS]->(f)
WHERE u.active = true
RETURN f.name, COUNT(*) AS cnt
GROUP BY f.name
ORDER BY cnt DESC;

Snippets Share link

Common patterns available as snippets:

Choosing an Editor Share link

Decision Guide Share link

Choose VS Code if:

• You want graph visualization for results
• You prefer a GUI-based debugging experience
• You need extensive extension ecosystem
• You’re new to GQL development

Choose Neovim if:

• You prefer modal editing
• You want maximum customization via Lua
• You value terminal-based workflows
• You need fast startup times

Choose Vim if:

• You need broad compatibility (SSH, minimal systems)
• You prefer traditional Vimscript configuration
• You have existing Vim workflows

Choose JetBrains IDEs if:

• You’re already using IntelliJ/DataGrip
• You want integrated database tooling
• Your team uses JetBrains products

Choose Emacs if:

• You’re an Emacs user
• You want consistent LSP integration
• You prefer Lisp-based configuration

Feature Comparison Share link

Configuration Best Practices Share link

Project-Level Configuration Share link

Create editor configuration files in your project:

project/
├── .vscode/
│   └── settings.json      # VS Code settings
├── .nvim.lua              # Neovim project config
├── .geode.json            # Geode connection config
└── queries/
    └── *.gql              # Query files

Geode Connection Config (.geode.json):

{
  "connections": {
    "development": {
      "host": "localhost",
      "port": 3141,
      "database": "dev"
    },
    "staging": {
      "host": "staging.example.com",
      "port": 3141,
      "database": "staging",
      "tls": true
    }
  },
  "defaultConnection": "development",
  "formatting": {
    "keywordCase": "UPPER",
    "indentSize": 2
  }
}

Team Configuration Share link

Share consistent settings across the team:

// .vscode/settings.json (committed to repo)
{
  "geode.formatting.formatOnSave": true,
  "geode.formatting.keywordCase": "UPPER",
  "geode.diagnostics.enabled": true,
  "[gql]": {
    "editor.tabSize": 2,
    "editor.formatOnSave": true
  }
}

Environment-Specific Settings Share link

Use environment variables for sensitive configuration:

# Development
export GEODE_HOST=localhost
export GEODE_PORT=3141

# Production (read-only)
export GEODE_HOST=prod.example.com
export GEODE_READ_ONLY=true

Troubleshooting Share link

Common Issues Share link

LSP Not Starting:

# Verify Geode installation
which geode
geode --version

# Test LSP manually
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | geode lsp --stdio

# Check permissions
ls -la $(which geode)

No Auto-Completion:

• Ensure LSP is connected to database
• Check schema cache is populated
• Verify file type is detected as gql

Slow Performance:

• Reduce diagnostic debounce time
• Limit number of problems reported
• Check database connection latency

Connection Failures:

# Test connectivity
nc -zv localhost 3141

# Test TLS
openssl s_client -connect localhost:3141

# Check server status
geode shell -h localhost -p 3141

Debug Logging Share link

Enable verbose logging:

# LSP debug mode
geode lsp --stdio --log-level debug --log-file /tmp/geode-lsp.log

# View logs
tail -f /tmp/geode-lsp.log

Getting Help Share link

• Check editor-specific documentation
• Review LSP logs for errors
• Test with minimal configuration
• Report issues on GitHub

Related Topics Share link

• VS Code Extension - Detailed VS Code guide
• Neovim Plugin - Neovim configuration
• Vim Plugin - Classic Vim setup
• IDE Integration - IDE-specific features
• Plugin Development - Creating custom plugins
• LSP Guide - LSP implementation details

Further Reading Share link

• Language Server Protocol Specification
• Editor-Specific Documentation
• GQL Language Reference
• Query Development Best Practices
• Team Collaboration Workflows
• Performance Optimization Guide