[Help Needed] JSONLS doesn't give me more than $schema for autocompletion

[johnend]

I have configured blink with nvim-lspconfig and all my lsps are working as expected. However, JSONLS refuses to give me any schema level autocomplete for keys in any json files, I only get $schema as a single option for completion.

NeoVim configs below:

lsp/init.lua

return {
  "neovim/nvim-lspconfig",
  event = { "BufReadPre", "BufNewFile" },
  dependencies = {
    -- mason.nvim will be set up with opts = {}
    { "mason-org/mason.nvim", opts = {
      ui = {
        border = "rounded",
      },
    } },
    "mason-org/mason-lspconfig.nvim",
    "WhoIsSethDaniel/mason-tool-installer.nvim",
    "saghen/blink.cmp",
    "b0o/schemastore.nvim",
  },
  config = function()
    local schemastore = require "schemastore"
    -- 1) Define the servers we actually want, and any special settings
    local servers = {
      bashls = {},
      cssls = {},
      css_variables = {},
      cssmodules_ls = {},
      emmet_language_server = {},
      eslint = {},
      graphql = {},
      helm_ls = {},
      html = {},
      jsonls = {
        schemaStore = {
          enable = false,
          url = "",
        },
        schemas = schemastore.json.schemas(),
      },
      lua_ls = {
        settings = {
          Lua = {
            completion = { callSnippet = "Replace" },
            diagnostics = { disable = { "missing-fields" } }, -- fix: use '=' not '-'
          },
        },
      },
      pyright = {},
      somesass_ls = {},
      terraformls = {},
      tflint = {},
      vtsls = {
        settings = {
          yaml = {
            schemaStore = {
              enable = false,
              url = "",
            },
            schemas = schemastore.yaml.schemas(),
          },
        },
      },
      yamlls = {},
      -- add other servers here, e.g. pyright = {}, tsserver = {}, etc.
    }

    local formatters = { "stylua", "prettier", "prettierd" }
    -- local dap = { "js-debug-adapter", "codelldb" } -- table for formatters

    -- 2) Turn Blink into LSP-capabilities for cmp
    local capabilities = require("blink.cmp").get_lsp_capabilities()

    -- 3) Ensure mason-tool-installer actually installs the right binaries
    local ensure_tools = vim.tbl_keys(servers) -- e.g. { "lua_ls" }

    vim.list_extend(ensure_tools, formatters) -- add stylua as a formatter
    -- vim.list_extend(ensure_tools, dap) -- uncomment to add dap tooling
    require("mason-tool-installer").setup {
      ensure_installed = ensure_tools,
    }

    -- 4) Configure mason-lspconfig to install & wire up our LSPs
    require("mason-lspconfig").setup {
      ensure_installed = vim.tbl_keys(servers),
      automatic_installation = true,
      automatic_enable = true,
      handlers = {
        -- default handler (will be called for each server_name)
        function(server_name)
          local opts = vim.tbl_deep_extend("force", { capabilities = capabilities }, servers[server_name] or {})
          require("lspconfig")[server_name].setup(opts)
        end,
      },
    }

    ------------------------------------------------

    local sign_keys = {
      Error = "Error",
      Warning = "Warn",
      Information = "Info",
      Hint = "Hint",
    }

    for long, short in pairs(sign_keys) do
      local icon = icons.diagnostics[long]
      local hl = "DiagnosticSign" .. short
      vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl })
    end

    -- diagnostics styling
    vim.diagnostic.config {
      severity_sort = true,
      float = { border = "rounded", source = "if_many" },
      underline = { severity = vim.diagnostic.severity.WARN },
      signs = vim.g.have_nerd_font and {
        text = {
          [vim.diagnostic.severity.ERROR] = icons.diagnostics.Error,
          [vim.diagnostic.severity.WARN] = icons.diagnostics.Warning,
          [vim.diagnostic.severity.INFO] = icons.diagnostics.Information,
          [vim.diagnostic.severity.HINT] = icons.diagnostics.Hint,
        },
      } or {},
      virtual_text = false,
    }

    -- 5) Finally, set up our LspAttach autocmd for keymaps & highlights
    local group = vim.api.nvim_create_augroup("lsp-attach", { clear = true })
    vim.api.nvim_create_autocmd("LspAttach", {
      group = group,
      callback = function(event)
        -- helper for buffer-local mappings
        local function map(keys, func, desc, mode)
          mode = mode or "n"
          vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = "LSP: " .. desc })
        end

        -- your mappings…
        map("gW", require("telescope.builtin").lsp_dynamic_workspace_symbols, "Workspace Symbols")
        map("grD", vim.lsp.buf.declaration, "Declaration")
        map("gra", require("actions-preview").code_actions, "Code Action")
        map("grd", require("telescope.builtin").lsp_definitions, "Definitions")
        map("gre", vim.diagnostic.open_float, "Open Diagnostic Float", { "n", "x" })
        map("gri", require("telescope.builtin").lsp_implementations, "Implementations")
        map("grj", function()
          vim.diagnostic.jump { count = 1 }
        end, "Next diagnostic", { "n", "x" })
        map("grk", function()
          vim.diagnostic.jump { count = -1 }
        end, "Previous diagnostic", { "n", "x" })
        map("grl", vim.diagnostic.setloclist, "Diagnostic loclist", { "n", "x" })
        map("grn", vim.lsp.buf.rename, "Rename")
        map("grr", require("telescope.builtin").lsp_references, "References")
        map("grs", ":Trouble symbols toggle focus=true<cr>", "Document Symbols")
        map("grt", require("telescope.builtin").lsp_type_definitions, "Type Definitions")

        -- highlight on CursorHold, clear on move
        local client = vim.lsp.get_client_by_id(event.data.client_id)
        if client and client:supports_method "textDocument/documentHighlight" then
          local hl_grp = vim.api.nvim_create_augroup("lsp-highlight", { clear = false })
          vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, {
            buffer = event.buf,
            group = hl_grp,
            callback = vim.lsp.buf.document_highlight,
          })
          vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, {
            buffer = event.buf,
            group = hl_grp,
            callback = vim.lsp.buf.clear_references,
          })
          vim.api.nvim_create_autocmd("LspDetach", {
            group = hl_grp,
            buffer = event.buf,
            callback = function(ev2)
              vim.lsp.buf.clear_references()
              vim.api.nvim_clear_autocmds { group = "lsp-highlight", buffer = ev2.buf }
            end,
          })
        end
      end,
    })
  end,
}

lsp/blink.lua

return {
  "saghen/blink.cmp",
  -- only load when we enter insert or cmdline
  version = "1.*",
  event = { "InsertEnter", "CmdlineEnter" },
  dependencies = {
    {
      "L3MON4D3/LuaSnip",
      build = (function()
        if vim.fn.has "win32" == 1 or vim.fn.executable "make" == 0 then
          return
        end
        return "make install_jsregexp"
      end)(),
      dependencies = {
        {
          "rafamadriz/friendly-snippets",
          config = function()
            require("luasnip.loaders.from_vscode").lazy_load()
          end,
        },
        "folke/lazydev.nvim",
        "onsails/lspkind.nvim",
        "xzbdmw/colorful-menu.nvim",
      },
    },
  },
  -- this opts block now configures blink.cmp itself, not LuaSnip!
  opts = {
    enabled = function()
      local filetype = vim.bo[0].filetype
      if filetype == "TelescopePrompt" then
        return false
      end
      return true
    end,

    sources = {
      default = { "lsp", "path", "snippets", "buffer", "lazydev" },
      providers = {
        lsp = {
          enabled = true,
          name = "LSP",
          module = "blink.cmp.sources.lsp",
          score_offset = 100,
        },
        lazydev = {
          enabled = true,
          name = "LazyDev",
          module = "lazydev.integrations.blink",
          score_offset = 90,
        },
        snippets = {
          enabled = true,
          name = "LuaSnip",
          max_items = 15,
          min_keyword_length = 2,
          module = "blink.cmp.sources.snippets",
          score_offset = 80,
        },
        path = {
          enabled = true,
          name = "Path",
          module = "blink.cmp.sources.path",
          score_offset = 30,
          fallbacks = { "snippets", "buffer" },
          opts = {
            trailing_slash = false,
            label_trailing_slash = true,
          },
        },
        buffers = {
          enabled = true,
          name = "Buffer",
          max_items = 5,
          module = "blink.cmp.sources.buffer",
          score_offset = 10,
        },
      },
    },

    keymap = {
      -- use the built-in preset; see docs for other presets :contentReference[oaicite:0]{index=0}
      preset = "default",
      ["<C-e>"] = {
        function(cmp)
          cmp.show { providers = { "lsp", "snippets", "buffers" } }
        end,
      },
      ["<Up>"] = {},
      ["<Down>"] = {},
      -- you can override individual keys here, too
    },

    appearance = {
      nerd_font_variant = "mono",
      kind_icons = icons.kind,
    },
    completion = {
      list = {
        selection = {
          preselect = false,
          auto_insert = false,
        },
      },
      documentation = {
        window = {
          border = "rounded",
          winhighlight = "FloatBorder:FloatBorder",
        },
        auto_show = true,
        auto_show_delay_ms = 300,
      },
      menu = {
        border = "rounded",
        winhighlight = "FloatBorder:FloatBorder",
        -- Controls how the completion items are rendered on the popup window
        draw = {
          -- Aligns the keyword you've typed to a component in the menu
          align_to = "label", -- or 'none' to disable, or 'cursor' to align to the cursor
          -- Left and right padding, optionally { left, right } for different padding on each side
          padding = 1,
          -- Gap between columns
          gap = 1,
          -- Priority of the cursorline highlight, setting this to 0 will render it below other highlights
          cursorline_priority = 10000,
          -- Use treesitter to highlight the label text for the given list of sources
          treesitter = { "lsp", "buffers" },
          -- treesitter = { 'lsp' }

          -- Components to render, grouped by column
          columns = { { "kind_icon" }, { "label", "label_description", gap = 1 }, { "source_name" } },
          -- Definitions for possible components to render. Each defines:
          --   ellipsis: whether to add an ellipsis when truncating the text
          --   width: control the min, max and fill behavior of the component
          --   text function: will be called for each item
          --   highlight function: will be called only when the line appears on screen
          components = {

            kind_icon = {
              ellipsis = false,
              text = function(ctx)
                return ctx.kind_icon .. ctx.icon_gap
              end,
              -- Set the highlight priority to 20000 to beat the cursorline's default priority of 10000
              highlight = function(ctx)
                return { { group = ctx.kind_hl, priority = 20000 } }
              end,
            },

            kind = {
              ellipsis = false,
              width = { fill = true },
              text = function(ctx)
                return ctx.kind
              end,
              highlight = function(ctx)
                return ctx.kind_hl
              end,
            },

            label = {
              width = { fill = true, max = 60 },
              text = function(ctx)
                return require("colorful-menu").blink_components_text(ctx)
              end,
              highlight = function(ctx)
                return require("colorful-menu").blink_components_highlight(ctx)
              end,
            },

            label_description = {
              width = { max = 30 },
              text = function(ctx)
                return ctx.label_description
              end,
              highlight = "BlinkCmpLabelDescription",
            },

            source_name = {
              width = { max = 30 },
              text = function(ctx)
                return ctx.source_name
              end,
              highlight = "BlinkCmpSource",
            },

            source_id = {
              width = { max = 30 },
              text = function(ctx)
                return ctx.source_id
              end,
              highlight = "BlinkCmpSource",
            },
          },
        },
      },
    },
    snippets = {
      preset = "luasnip",
    },
    fuzzy = {
      implementation = "prefer_rust_with_warning",
      use_frecency = false,
    },
    signature = {
      enabled = true,
      window = {
        border = "rounded",
        winhighlight = "FloatBorder:FloatBorder",
      },
    },
  },
  -- ensure Lazy.nvim actually calls the setup
  config = function(_, opts)
    local status_ok, blink = pcall(require, "blink.cmp")
    if not status_ok then
      return
    end

    blink.setup(opts) -- wire your opts into blink :contentReference[oaicite:1]{index=1}
  end,
}

This is true with default jsonls, or with a specific filename declared e.g. pointing a package.json config option towards the specific schema in schemastore, or by using the b0o/schemastore.nvim plugin as intended.

The only thing that actually gets me autocompletion is by adding the $schema key directly within the file e.g.

{
  "$schema": "https://json.schemastore.org/package.json"
  ...rest
}

I don't fully remember if this work with nvim-cmp.

Full link to my config: https://github.com/johnend/dots/tree/main/common/.config/nvim

[soifou]

At first sight I would say you're missing settings.json property in your jsonls.

Instead of this:

 jsonls = {
    schemaStore = {
      enable = false,
      url = "",
    },
    schemas = schemastore.json.schemas(),
  },

Try the following:

jsonls = {
  settings = {
    json = {
      schemaStore = {
        enable = false,
        url = "",
      },
      schemas = schemastore.json.schemas(),
    },
  },
},

[johnend]

This still does the same, I'm pretty sure I tried this before too:

This is true in package.json (this is an example vite app) and also other json files so my suspicion is that it's either an LSP issue, or cmp? Wouldn't want to make assumptions though.

[johnend]

FYI see the same behavior on Mac (not that that should really make a difference in this case).

Didn't want to raise any issues anywhere until I figured it out, but I tried seeing if there were other issues with jsonls #1500 is the only thing I've found that comes close.

[soifou]

Looking at the readme usage section of schemastore.nvim, the following block seems useful only for yamlls not jsonls so maybe that's the problem here?

      schemaStore = {
        enable = false,
        url = "",
      },

And I don't think there any problem with blink, this works fine with my config. Here is my current settings:

    settings = {
        json = {
            validate = { enable = true },
            schemas = vim.list_extend({
                -- In case you want to add an unsupported schema by schemastore
                {
                    description = 'Lua language server config file',
                    fileMatch = { '.luarc.json' },
                    url = 'https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json',
                },
            }, require('schemastore').json.schemas()),
        },
    },

[johnend]

I tried your setup and it still doesn't work for me. The only way I can get specific keys to show in completion is to include the schema directly in the JSON file as a key/value pair.

I can't understand it, the other language servers work as expected, it's only jsonls that gives me this behavior. Presumably it wouldn't be another plugin causing this issue as these are the only json references in my config:

Thank you for looking at this by the way 😄