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

Server process backing the GraphQL Language Service

import { MessageProcessor } from './MessageProcessor';
import { IPCMessageReader, IPCMessageWriter, SocketMessageReader, SocketMessageWriter, StreamMessageReader, StreamMessageWriter, } from 'vscode-jsonrpc/node';
import { CompletionRequest, CompletionResolveRequest, DefinitionRequest, DidOpenTextDocumentNotification, DidSaveTextDocumentNotification, DidChangeTextDocumentNotification, DidChangeConfigurationNotification, DidCloseTextDocumentNotification, ExitNotification, HoverRequest, InitializeRequest, PublishDiagnosticsNotification, DidChangeWatchedFilesNotification, ShutdownRequest, DocumentSymbolRequest, WorkspaceSymbolRequest, createConnection as createLanguageServerConnection, } from 'vscode-languageserver/node';
import { Logger } from './Logger';
import { DEFAULT_SUPPORTED_EXTENSIONS, DEFAULT_SUPPORTED_GRAPHQL_EXTENSIONS, } from './constants';
import { createConnection } from 'node:net';
export const buildOptions = (options) => {
    const serverOptions = { ...options };
    if (serverOptions.loadConfigOptions) {
        const { extensions, rootDir } = serverOptions.loadConfigOptions;
        if (extensions) {
            serverOptions.loadConfigOptions.extensions = extensions;
        }
        if (!rootDir) {
            if (serverOptions.configDir) {
                serverOptions.loadConfigOptions.rootDir = serverOptions.configDir;
            }
            else {
                serverOptions.loadConfigOptions.rootDir = process.cwd();
            }
        }
    }
    else {
        serverOptions.loadConfigOptions = {
            rootDir: options.configDir || process.cwd(),
            extensions: serverOptions.extensions || [],
        };
    }
    return serverOptions;
};
export default async function startServer(options) {
    const finalOptions = buildOptions({ method: 'node', ...options });
    let reader;
    let writer;
    switch (finalOptions.method) {
        case 'socket':
            if (!finalOptions.port) {
                process.stderr.write('--port is required to establish socket connection.');
                process.exit(1);
            }
            const { port, hostname, encoding } = finalOptions;
            const socket = createConnection(port, hostname !== null && hostname !== void 0 ? hostname : '127.0.01');
            reader = new SocketMessageReader(socket, encoding !== null && encoding !== void 0 ? encoding : 'utf-8');
            writer = new SocketMessageWriter(socket, encoding !== null && encoding !== void 0 ? encoding : 'utf-8');
            break;
        case 'stream':
            reader = new StreamMessageReader(process.stdin);
            writer = new StreamMessageWriter(process.stdout);
            break;
        default:
            reader = new IPCMessageReader(process);
            writer = new IPCMessageWriter(process);
            break;
    }
    const streamServer = await initializeHandlers({
        reader,
        writer,
        options: finalOptions,
    });
    streamServer.listen();
    return streamServer;
}
export async function initializeHandlers({ reader, writer, options, }) {
    const connection = createLanguageServerConnection(reader, writer);
    const logger = new Logger(connection, options.debug);
    try {
        await addHandlers({ connection, logger, ...options });
        return connection;
    }
    catch (err) {
        logger.error('There was an error initializing the server connection');
        logger.error(String(err));
        process.exit(1);
    }
}
function reportDiagnostics(diagnostics, connection) {
    if (diagnostics) {
        void connection.sendNotification(PublishDiagnosticsNotification.type, diagnostics);
    }
}
export 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, messageProcessor.handleDidCloseNotification);
    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.onNotification(DidChangeConfigurationNotification.type, params => messageProcessor.handleDidChangeConfiguration(params));
}
//# sourceMappingURL=startServer.js.map