LSP-server-example

1
package server
2

3
import (
4
	"encoding/json"
5
	"errors"
6
)
7

8
const protocolVersion = "2.0"
9

10
type Message interface {
11
	IsJSONRPC() bool
12
}
13

14
type Request struct {
15
	ProtocolVersion string           `json:"jsonrpc"`
16
	ID              *json.RawMessage `json:"id"`
17
	Method          string           `json:"method"`
18
	Params          json.RawMessage  `json:"params"`
19
}
20

21
func (r Request) IsJSONRPC() bool {
22
	return r.ProtocolVersion == protocolVersion
23
}
24

25
func (r Request) IsNotification() bool {
26
	return r.ID == nil
27
}
28

29
type Response struct {
30
	ProtocolVersion string           `json:"jsonrpc"`
31
	ID              *json.RawMessage `json:"id"`
32
	Result          any              `json:"result"`
33
	Error           *Error           `json:"error"`
34
}
35

36
func (r Response) IsJSONRPC() bool {
37
	return r.ProtocolVersion == protocolVersion
38
}
39

40
type Error struct {
41
	// Code is a Number that indicates the error type that occurred.
42
	Code int64 `json:"code"`
43
	// Message of the error.
44
	// The message SHOULD be limited to a concise single sentence.
45
	Message string `json:"message"`
46
	// A Primitive or Structured value that contains additional information about the error.
47
	// This may be omitted.
48
	// The value of this member is defined by the Server (e.g. detailed error information, nested errors etc.).
49
	Data any `json:"data"`
50
}
51

52
func (e *Error) Error() string {
53
	return e.Message
54
}
55

56
var (
57
	ErrParseError           = &Error{Code: -32700, Message: "Parse error"}
58
	ErrInvalidRequest       = &Error{Code: -32600, Message: "Invalid Request"}
59
	ErrMethodNotFound       = &Error{Code: -32601, Message: "Method not found"}
60
	ErrInvalidParams        = &Error{Code: -32602, Message: "Invalid params"}
61
	ErrInternal             = &Error{Code: -32603, Message: "Internal error"}
62
	ErrServerNotInitialized = &Error{Code: -32002, Message: "Server not initialized"}
63
)
64
var ErrInvalidContentLengthHeader = errors.New("missing or invalid Content-Length header")
65

66
func NewResponseError(id *json.RawMessage, err error) Response {
67
	return Response{
68
		ProtocolVersion: protocolVersion,
69
		ID:              id,
70
		Result:          nil,
71
		Error:           newError(err),
72
	}
73
}
74

75
func newError(err error) *Error {
76
	if err == nil {
77
		return nil
78
	}
79
	var e *Error
80
	if errors.As(err, &e) {
81
		return e
82
	}
83
	return &Error{
84
		Code:    0,
85
		Message: err.Error(),
86
		Data:    nil,
87
	}
88
}
89

90
func NewResponse(id *json.RawMessage, result any) Response {
91
	return Response{
92
		ProtocolVersion: protocolVersion,
93
		ID:              id,
94
		Result:          result,
95
		Error:           nil,
96
	}
97
}
98

99
type Notification struct {
100
	ProtocolVersion string `json:"jsonrpc"`
101
	Method          string `json:"method"`
102
	Params          any    `json:"params"`
103
}
104

105
func (n Notification) IsJSONRPC() bool {
106
	return n.ProtocolVersion == protocolVersion
107
}
108