1const { Buffer } = require('buffer');
2const fs = require("fs");
3const path = require("path");
4const { once } = require('events');
5
6const prettierContainerPath = process.argv[2];
7if (prettierContainerPath == null || prettierContainerPath.length == 0) {
8 sendResponse(makeError(`Prettier path argument was not specified or empty.\nUsage: ${process.argv[0]} ${process.argv[1]} prettier/path`));
9 process.exit(1);
10}
11fs.stat(prettierContainerPath, (err, stats) => {
12 if (err) {
13 sendResponse(makeError(`Path '${prettierContainerPath}' does not exist.`));
14 process.exit(1);
15 }
16
17 if (!stats.isDirectory()) {
18 sendResponse(makeError(`Path '${prettierContainerPath}' exists but is not a directory.`));
19 process.exit(1);
20 }
21});
22const prettierPath = path.join(prettierContainerPath, 'node_modules/prettier');
23
24
25(async () => {
26 let prettier;
27 try {
28 prettier = await loadPrettier(prettierPath);
29 } catch (e) {
30 sendResponse(makeError(`Failed to load prettier: ${e}`));
31 process.exit(1);
32 }
33 sendResponse(makeError("Prettier loadded successfully."));
34 process.stdin.resume();
35 handleBuffer(prettier);
36})()
37
38async function handleBuffer(prettier) {
39 for await (let messageText of readStdin()) {
40 handleMessage(messageText, prettier).catch(e => {
41 sendResponse(makeError(`error during message handling: ${e}`));
42 });
43 }
44}
45
46async function* readStdin() {
47 let buffer = Buffer.alloc(0);
48 let streamEnded = false;
49 process.stdin.on('end', () => {
50 streamEnded = true;
51 });
52 process.stdin.on('data', (data) => {
53 buffer = Buffer.concat([buffer, data]);
54 });
55
56 async function handleStreamEnded(errorMessage) {
57 sendResponse(makeError(errorMessage));
58 buffer = Buffer.alloc(0);
59 messageLength = null;
60 await once(process.stdin, 'readable');
61 streamEnded = false;
62 }
63
64 try {
65 const headersSeparator = "\r\n\r\n";
66 let contentLengthHeaderName = 'Content-Length';
67 let headersLength = null;
68 let messageLength = null;
69 main_loop: while (true) {
70 if (messageLength === null) {
71 while (buffer.indexOf(headersSeparator) === -1) {
72 if (streamEnded) {
73 await handleStreamEnded('Unexpected end of stream: headers not found');
74 continue main_loop;
75 } else if (buffer.length > contentLengthHeaderName.length * 10) {
76 await handleStreamEnded(`Unexpected stream of bytes: no headers end found after ${buffer.length} bytes of input`);
77 continue main_loop;
78 }
79 await once(process.stdin, 'readable');
80 }
81 const headers = buffer.subarray(0, buffer.indexOf(headersSeparator)).toString('ascii');
82 const contentLengthHeader = headers.split('\r\n').map(header => header.split(': '))
83 .filter(header => header[2] === undefined)
84 .filter(header => (header[1] || '').length > 0)
85 .find(header => header[0].trim() === contentLengthHeaderName);
86 if (contentLengthHeader === undefined) {
87 await handleStreamEnded(`Missing or incorrect Content-Length header: ${headers}`);
88 continue main_loop;
89 }
90 headersLength = headers.length + headersSeparator.length;
91 messageLength = parseInt(contentLengthHeader[1], 10);
92 }
93
94 while (buffer.length < (headersLength + messageLength)) {
95 if (streamEnded) {
96 await handleStreamEnded(
97 `Unexpected end of stream: buffer length ${buffer.length} does not match expected header length ${headersLength} + body length ${messageLength}`);
98 continue main_loop;
99 }
100 await once(process.stdin, 'readable');
101 }
102
103 const messageEnd = headersLength + messageLength;
104 const message = buffer.subarray(headersLength, messageEnd);
105 buffer = buffer.subarray(messageEnd);
106 messageLength = null;
107 yield message.toString('utf8');
108 }
109 } catch (e) {
110 sendResponse(makeError(`Error reading stdin: ${e}`));
111 } finally {
112 process.stdin.off('data', () => { });
113 }
114}
115
116// ?
117// shutdown
118// error
119async function handleMessage(messageText, prettier) {
120 const message = JSON.parse(messageText);
121 const { method, id, params } = message;
122 if (method === undefined) {
123 throw new Error(`Message method is undefined: ${messageText}`);
124 }
125 if (id === undefined) {
126 throw new Error(`Message id is undefined: ${messageText}`);
127 }
128
129 if (method === 'prettier/format') {
130 if (params === undefined || params.text === undefined) {
131 throw new Error(`Message params.text is undefined: ${messageText}`);
132 }
133 let formattedText = await prettier.format(params.text);
134 sendResponse({ id, result: { text: formattedText } });
135 } else if (method === 'prettier/clear_cache') {
136 prettier.clearConfigCache();
137 sendResponse({ id, result: null });
138 } else if (method === 'initialize') {
139 sendResponse({
140 id,
141 result: {
142 "capabilities": {}
143 }
144 });
145 } else {
146 throw new Error(`Unknown method: ${method}`);
147 }
148}
149
150function makeError(message) {
151 return {
152 error: {
153 "code": -32600, // invalid request code
154 message,
155 }
156 };
157}
158
159function sendResponse(response) {
160 let responsePayloadString = JSON.stringify({
161 jsonrpc: "2.0",
162 ...response
163 });
164 let headers = `Content-Length: ${Buffer.byteLength(responsePayloadString)}\r\n\r\n`;
165 let dataToSend = headers + responsePayloadString;
166 process.stdout.write(dataToSend);
167}
168
169function loadPrettier(prettierPath) {
170 return new Promise((resolve, reject) => {
171 fs.access(prettierPath, fs.constants.F_OK, (err) => {
172 if (err) {
173 reject(`Path '${prettierPath}' does not exist.Error: ${err}`);
174 } else {
175 try {
176 resolve(require(prettierPath));
177 } catch (err) {
178 reject(`Error requiring prettier module from path '${prettierPath}'.Error: ${err}`);
179 }
180 }
181 });
182 });
183}