graphql-language-service-server/esm/startServer.js

Server process backing the GraphQL Language Service

import * as net from 'net';
import { MessageProcessor } from './MessageProcessor';
import { IPCMessageReader, IPCMessageWriter, SocketMessageReader, SocketMessageWriter, StreamMessageReader, StreamMessageWriter, } from 'vscode-jsonrpc';
import { CompletionRequest, CompletionResolveRequest, DefinitionRequest, DidOpenTextDocumentNotification, DidSaveTextDocumentNotification, DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, ExitNotification, HoverRequest, InitializeRequest, PublishDiagnosticsNotification, DidChangeWatchedFilesNotification, ShutdownRequest, DocumentSymbolRequest, WorkspaceSymbolRequest, createConnection, } from 'vscode-languageserver';
import { Logger } from './Logger';
import { DEFAULT_SUPPORTED_EXTENSIONS, DEFAULT_SUPPORTED_GRAPHQL_EXTENSIONS, } from './parseDocument';
const buildOptions = (options) => {
    const serverOptions = { ...options };
    if (serverOptions.loadConfigOptions) {
        const { extensions } = serverOptions.loadConfigOptions;
        if (!serverOptions.loadConfigOptions.rootDir) {
            if (serverOptions.configDir) {
                serverOptions.loadConfigOptions.rootDir = serverOptions.configDir;
            }
            else {
                serverOptions.loadConfigOptions.rootDir = process.cwd();
            }
        }
        if (serverOptions.extensions) {
            serverOptions.loadConfigOptions.extensions = [
                ...serverOptions.extensions,
                ...(extensions || []),
            ];
        }
    }
    else {
        serverOptions.loadConfigOptions = {
            rootDir: options.configDir || process.cwd(),
            extensions: [],
        };
    }
    return serverOptions;
};
export default async function startServer(options) {
    if (options && options.method) {
        const stderrOnly = options.method === 'stream';
        const logger = new Logger(options.tmpDir, stderrOnly);
        const finalOptions = buildOptions(options);
        let reader;
        let writer;
        switch (options.method) {
            case 'socket':
                if (!options.port) {
                    process.stderr.write('--port is required to establish socket connection.');
                    process.exit(1);
                }
                const port = options.port;
                const hostname = options.hostname;
                const socket = net
                    .createServer(client => {
                    client.setEncoding('utf8');
                    reader = new SocketMessageReader(client);
                    writer = new SocketMessageWriter(client);
                    client.on('end', () => {
                        socket.close();
                        process.exit(0);
                    });
                    return initializeHandlers({
                        reader,
                        writer,
                        logger,
                        options: finalOptions,
                    }).then(s => {
                        s.listen();
                    });
                })
                    .listen(port, hostname);
                return;
            case 'stream':
                reader = new StreamMessageReader(process.stdin);
                writer = new StreamMessageWriter(process.stdout);
                break;
            case 'node':
            default:
                reader = new IPCMessageReader(process);
                writer = new IPCMessageWriter(process);
                break;
        }
        try {
            const serverWithHandlers = await initializeHandlers({
                reader,
                writer,
                logger,
                options: finalOptions,
            });
            serverWithHandlers.listen();
        }
        catch (err) {
            logger.error('There was a Graphql LSP handler exception:');
            logger.error(err);
        }
    }
}
async function initializeHandlers({ reader, writer, logger, options, }) {
    try {
        const connection = createConnection(reader, writer);
        await addHandlers({ connection, logger, ...options });
        return connection;
    }
    catch (err) {
        logger.error('There was an error initializing the server connection');
        logger.error(err);
        process.exit(1);
    }
}
function reportDiagnostics(diagnostics, connection) {
    if (diagnostics) {
        connection.sendNotification(PublishDiagnosticsNotification.type, diagnostics);
    }
}
async function addHandlers({ connection, logger, config, parser, fileExtensions, graphqlFileExtensions, tmpDir, loadConfigOptions, }) {
    const messageProcessor = new MessageProcessor({
        logger,
        config,
        parser,
        fileExtensions: fileExtensions || DEFAULT_SUPPORTED_EXTENSIONS,
        graphqlFileExtensions: graphqlFileExtensions || DEFAULT_SUPPORTED_GRAPHQL_EXTENSIONS,
        tmpDir,
        loadConfigOptions,
        connection,
    });
    connection.onNotification(DidOpenTextDocumentNotification.type, async (params) => {
        const diagnostics = await messageProcessor.handleDidOpenOrSaveNotification(params);
        reportDiagnostics(diagnostics, connection);
    });
    connection.onNotification(DidSaveTextDocumentNotification.type, async (params) => {
        const diagnostics = await messageProcessor.handleDidOpenOrSaveNotification(params);
        reportDiagnostics(diagnostics, connection);
    });
    connection.onNotification(DidChangeTextDocumentNotification.type, async (params) => {
        const diagnostics = await messageProcessor.handleDidChangeNotification(params);
        reportDiagnostics(diagnostics, connection);
    });
    connection.onNotification(DidCloseTextDocumentNotification.type, params => messageProcessor.handleDidCloseNotification(params));
    connection.onRequest(ShutdownRequest.type, () => messageProcessor.handleShutdownRequest());
    connection.onNotification(ExitNotification.type, () => messageProcessor.handleExitNotification());
    connection.onNotification('$/cancelRequest', () => ({}));
    connection.onRequest(InitializeRequest.type, (params, token) => messageProcessor.handleInitializeRequest(params, token, loadConfigOptions.rootDir));
    connection.onRequest(CompletionRequest.type, params => messageProcessor.handleCompletionRequest(params));
    connection.onRequest(CompletionResolveRequest.type, item => item);
    connection.onRequest(DefinitionRequest.type, params => messageProcessor.handleDefinitionRequest(params));
    connection.onRequest(HoverRequest.type, params => messageProcessor.handleHoverRequest(params));
    connection.onNotification(DidChangeWatchedFilesNotification.type, params => messageProcessor.handleWatchedFilesChangedNotification(params));
    connection.onRequest(DocumentSymbolRequest.type, params => messageProcessor.handleDocumentSymbolRequest(params));
    connection.onRequest(WorkspaceSymbolRequest.type, params => messageProcessor.handleWorkspaceSymbolRequest(params));
    connection.onDidChangeConfiguration(messageProcessor.handleDidChangeConfiguration);
}
//# sourceMappingURL=startServer.js.map